home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / awt / Component.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  56.3 KB  |  3,569 lines
  1. package java.awt;
  2.  
  3. import java.applet.Applet;
  4. import java.awt.BufferCapabilities.FlipContents;
  5. import java.awt.GraphicsCallback.PeerPaintCallback;
  6. import java.awt.GraphicsCallback.PeerPrintCallback;
  7. import java.awt.dnd.DropTarget;
  8. import java.awt.event.ComponentEvent;
  9. import java.awt.event.ComponentListener;
  10. import java.awt.event.FocusEvent;
  11. import java.awt.event.FocusListener;
  12. import java.awt.event.HierarchyBoundsListener;
  13. import java.awt.event.HierarchyEvent;
  14. import java.awt.event.HierarchyListener;
  15. import java.awt.event.InputEvent;
  16. import java.awt.event.InputMethodEvent;
  17. import java.awt.event.InputMethodListener;
  18. import java.awt.event.KeyEvent;
  19. import java.awt.event.KeyListener;
  20. import java.awt.event.MouseEvent;
  21. import java.awt.event.MouseListener;
  22. import java.awt.event.MouseMotionListener;
  23. import java.awt.event.MouseWheelEvent;
  24. import java.awt.event.MouseWheelListener;
  25. import java.awt.event.PaintEvent;
  26. import java.awt.event.WindowEvent;
  27. import java.awt.im.InputContext;
  28. import java.awt.im.InputMethodRequests;
  29. import java.awt.image.BufferStrategy;
  30. import java.awt.image.ColorModel;
  31. import java.awt.image.ImageObserver;
  32. import java.awt.image.ImageProducer;
  33. import java.awt.image.VolatileImage;
  34. import java.awt.peer.ComponentPeer;
  35. import java.awt.peer.ContainerPeer;
  36. import java.awt.peer.LightweightPeer;
  37. import java.beans.PropertyChangeListener;
  38. import java.beans.PropertyChangeSupport;
  39. import java.io.IOException;
  40. import java.io.ObjectInputStream;
  41. import java.io.ObjectOutputStream;
  42. import java.io.OptionalDataException;
  43. import java.io.PrintStream;
  44. import java.io.PrintWriter;
  45. import java.io.Serializable;
  46. import java.lang.reflect.InvocationTargetException;
  47. import java.lang.reflect.Method;
  48. import java.security.AccessController;
  49. import java.util.Collections;
  50. import java.util.EventListener;
  51. import java.util.HashSet;
  52. import java.util.Locale;
  53. import java.util.Map;
  54. import java.util.Set;
  55. import java.util.Vector;
  56. import java.util.WeakHashMap;
  57. import java.util.logging.Level;
  58. import java.util.logging.Logger;
  59. import javax.accessibility.Accessible;
  60. import javax.accessibility.AccessibleContext;
  61. import javax.accessibility.AccessibleSelection;
  62. import javax.accessibility.AccessibleState;
  63. import javax.accessibility.AccessibleStateSet;
  64. import javax.swing.JComponent;
  65. import sun.awt.AppContext;
  66. import sun.awt.CausedFocusEvent;
  67. import sun.awt.ConstrainableGraphics;
  68. import sun.awt.DebugHelper;
  69. import sun.awt.EmbeddedFrame;
  70. import sun.awt.RequestFocusController;
  71. import sun.awt.WindowClosingListener;
  72. import sun.awt.CausedFocusEvent.Cause;
  73. import sun.awt.dnd.SunDropTargetEvent;
  74. import sun.awt.im.CompositionArea;
  75. import sun.font.FontDesignMetrics;
  76. import sun.font.FontManager;
  77. import sun.security.action.GetPropertyAction;
  78.  
  79. public abstract class Component implements ImageObserver, MenuContainer, Serializable {
  80.    private static final Logger focusLog = Logger.getLogger("java.awt.focus.Component");
  81.    private static final Logger log = Logger.getLogger("java.awt.Component");
  82.    transient ComponentPeer peer;
  83.    transient Container parent;
  84.    transient AppContext appContext;
  85.    // $FF: renamed from: x int
  86.    int field_0;
  87.    // $FF: renamed from: y int
  88.    int field_1;
  89.    int width;
  90.    int height;
  91.    Color foreground;
  92.    Color background;
  93.    Font font;
  94.    Font peerFont;
  95.    Cursor cursor;
  96.    Locale locale;
  97.    transient GraphicsConfiguration graphicsConfig = null;
  98.    transient BufferStrategy bufferStrategy = null;
  99.    boolean ignoreRepaint = false;
  100.    boolean visible = true;
  101.    boolean enabled = true;
  102.    boolean valid = false;
  103.    DropTarget dropTarget;
  104.    Vector popups;
  105.    private String name;
  106.    private boolean nameExplicitlySet = false;
  107.    private boolean focusable = true;
  108.    private static final int FOCUS_TRAVERSABLE_UNKNOWN = 0;
  109.    private static final int FOCUS_TRAVERSABLE_DEFAULT = 1;
  110.    private static final int FOCUS_TRAVERSABLE_SET = 2;
  111.    private int isFocusTraversableOverridden = 0;
  112.    Set[] focusTraversalKeys;
  113.    private static final String[] focusTraversalKeyPropertyNames = new String[]{"forwardFocusTraversalKeys", "backwardFocusTraversalKeys", "upCycleFocusTraversalKeys", "downCycleFocusTraversalKeys"};
  114.    private boolean focusTraversalKeysEnabled = true;
  115.    static final Object LOCK = new AWTTreeLock();
  116.    Dimension minSize;
  117.    boolean minSizeSet;
  118.    Dimension prefSize;
  119.    boolean prefSizeSet;
  120.    Dimension maxSize;
  121.    boolean maxSizeSet;
  122.    transient ComponentOrientation componentOrientation;
  123.    boolean newEventsOnly;
  124.    transient ComponentListener componentListener;
  125.    transient FocusListener focusListener;
  126.    transient HierarchyListener hierarchyListener;
  127.    transient HierarchyBoundsListener hierarchyBoundsListener;
  128.    transient KeyListener keyListener;
  129.    transient MouseListener mouseListener;
  130.    transient MouseMotionListener mouseMotionListener;
  131.    transient MouseWheelListener mouseWheelListener;
  132.    transient InputMethodListener inputMethodListener;
  133.    transient RuntimeException windowClosingException;
  134.    static final String actionListenerK = "actionL";
  135.    static final String adjustmentListenerK = "adjustmentL";
  136.    static final String componentListenerK = "componentL";
  137.    static final String containerListenerK = "containerL";
  138.    static final String focusListenerK = "focusL";
  139.    static final String itemListenerK = "itemL";
  140.    static final String keyListenerK = "keyL";
  141.    static final String mouseListenerK = "mouseL";
  142.    static final String mouseMotionListenerK = "mouseMotionL";
  143.    static final String mouseWheelListenerK = "mouseWheelL";
  144.    static final String textListenerK = "textL";
  145.    static final String ownedWindowK = "ownedL";
  146.    static final String windowListenerK = "windowL";
  147.    static final String inputMethodListenerK = "inputMethodL";
  148.    static final String hierarchyListenerK = "hierarchyL";
  149.    static final String hierarchyBoundsListenerK = "hierarchyBoundsL";
  150.    static final String windowStateListenerK = "windowStateL";
  151.    static final String windowFocusListenerK = "windowFocusL";
  152.    long eventMask;
  153.    private static final DebugHelper dbg = DebugHelper.create(Component.class);
  154.    static boolean isInc;
  155.    static int incRate;
  156.    public static final float TOP_ALIGNMENT = 0.0F;
  157.    public static final float CENTER_ALIGNMENT = 0.5F;
  158.    public static final float BOTTOM_ALIGNMENT = 1.0F;
  159.    public static final float LEFT_ALIGNMENT = 0.0F;
  160.    public static final float RIGHT_ALIGNMENT = 1.0F;
  161.    private static final long serialVersionUID = -7644114512714619750L;
  162.    private PropertyChangeSupport changeSupport;
  163.    boolean isPacked;
  164.    private transient Object privateKey;
  165.    private int boundsOp;
  166.    transient EventQueueItem[] eventCache;
  167.    private transient boolean coalescingEnabled;
  168.    private static final Map<Class<?>, Boolean> coalesceMap;
  169.    private static final Class[] coalesceEventsParams;
  170.    private static RequestFocusController requestFocusController;
  171.    private int componentSerializedDataVersion;
  172.    transient NativeInLightFixer nativeInLightFixer;
  173.    AccessibleContext accessibleContext;
  174.  
  175.    int getBoundsOp() {
  176.       assert Thread.holdsLock(this.getTreeLock());
  177.  
  178.       return this.boundsOp;
  179.    }
  180.  
  181.    void setBoundsOp(int var1) {
  182.       assert Thread.holdsLock(this.getTreeLock());
  183.  
  184.       if (var1 == 5) {
  185.          this.boundsOp = 3;
  186.       } else if (this.boundsOp == 3) {
  187.          this.boundsOp = var1;
  188.       }
  189.  
  190.    }
  191.  
  192.    protected Component() {
  193.       this.componentOrientation = ComponentOrientation.UNKNOWN;
  194.       this.newEventsOnly = false;
  195.       this.windowClosingException = null;
  196.       this.eventMask = 4096L;
  197.       this.isPacked = false;
  198.       this.privateKey = new Object();
  199.       this.boundsOp = 3;
  200.       this.coalescingEnabled = this.checkCoalescing();
  201.       this.componentSerializedDataVersion = 4;
  202.       this.accessibleContext = null;
  203.       this.appContext = AppContext.getAppContext();
  204.    }
  205.  
  206.    void initializeFocusTraversalKeys() {
  207.       this.focusTraversalKeys = new Set[3];
  208.    }
  209.  
  210.    String constructComponentName() {
  211.       return null;
  212.    }
  213.  
  214.    public String getName() {
  215.       if (this.name == null && !this.nameExplicitlySet) {
  216.          synchronized(this) {
  217.             if (this.name == null && !this.nameExplicitlySet) {
  218.                this.name = this.constructComponentName();
  219.             }
  220.          }
  221.       }
  222.  
  223.       return this.name;
  224.    }
  225.  
  226.    public void setName(String var1) {
  227.       String var2;
  228.       synchronized(this) {
  229.          var2 = this.name;
  230.          this.name = var1;
  231.          this.nameExplicitlySet = true;
  232.       }
  233.  
  234.       this.firePropertyChange("name", var2, var1);
  235.    }
  236.  
  237.    public Container getParent() {
  238.       return this.getParent_NoClientCode();
  239.    }
  240.  
  241.    final Container getParent_NoClientCode() {
  242.       return this.parent;
  243.    }
  244.  
  245.    /** @deprecated */
  246.    @Deprecated
  247.    public ComponentPeer getPeer() {
  248.       return this.peer;
  249.    }
  250.  
  251.    public synchronized void setDropTarget(DropTarget var1) {
  252.       if (var1 != this.dropTarget && (this.dropTarget == null || !this.dropTarget.equals(var1))) {
  253.          DropTarget var2;
  254.          if ((var2 = this.dropTarget) != null) {
  255.             if (this.peer != null) {
  256.                this.dropTarget.removeNotify(this.peer);
  257.             }
  258.  
  259.             DropTarget var3 = this.dropTarget;
  260.             this.dropTarget = null;
  261.  
  262.             try {
  263.                var3.setComponent((Component)null);
  264.             } catch (IllegalArgumentException var6) {
  265.             }
  266.          }
  267.  
  268.          if ((this.dropTarget = var1) != null) {
  269.             try {
  270.                this.dropTarget.setComponent(this);
  271.                if (this.peer != null) {
  272.                   this.dropTarget.addNotify(this.peer);
  273.                }
  274.             } catch (IllegalArgumentException var7) {
  275.                if (var2 != null) {
  276.                   try {
  277.                      var2.setComponent(this);
  278.                      if (this.peer != null) {
  279.                         this.dropTarget.addNotify(this.peer);
  280.                      }
  281.                   } catch (IllegalArgumentException var5) {
  282.                   }
  283.                }
  284.             }
  285.          }
  286.  
  287.       }
  288.    }
  289.  
  290.    public synchronized DropTarget getDropTarget() {
  291.       return this.dropTarget;
  292.    }
  293.  
  294.    public GraphicsConfiguration getGraphicsConfiguration() {
  295.       synchronized(this.getTreeLock()) {
  296.          if (this.graphicsConfig != null) {
  297.             return this.graphicsConfig;
  298.          } else {
  299.             return this.getParent() != null ? this.getParent().getGraphicsConfiguration() : null;
  300.          }
  301.       }
  302.    }
  303.  
  304.    final GraphicsConfiguration getGraphicsConfiguration_NoClientCode() {
  305.       GraphicsConfiguration var1 = this.graphicsConfig;
  306.       Container var2 = this.parent;
  307.       if (var1 != null) {
  308.          return var1;
  309.       } else {
  310.          return var2 != null ? var2.getGraphicsConfiguration_NoClientCode() : null;
  311.       }
  312.    }
  313.  
  314.    void resetGC() {
  315.       synchronized(this.getTreeLock()) {
  316.          this.graphicsConfig = null;
  317.       }
  318.    }
  319.  
  320.    void setGCFromPeer() {
  321.       synchronized(this.getTreeLock()) {
  322.          if (this.peer != null) {
  323.             this.graphicsConfig = this.peer.getGraphicsConfiguration();
  324.          } else {
  325.             this.graphicsConfig = null;
  326.          }
  327.  
  328.       }
  329.    }
  330.  
  331.    void checkGD(String var1) {
  332.       if (this.graphicsConfig != null && !this.graphicsConfig.getDevice().getIDstring().equals(var1)) {
  333.          throw new IllegalArgumentException("adding a container to a container on a different GraphicsDevice");
  334.       }
  335.    }
  336.  
  337.    public final Object getTreeLock() {
  338.       return LOCK;
  339.    }
  340.  
  341.    public Toolkit getToolkit() {
  342.       return this.getToolkitImpl();
  343.    }
  344.  
  345.    final Toolkit getToolkitImpl() {
  346.       ComponentPeer var1 = this.peer;
  347.       if (var1 != null && !(var1 instanceof LightweightPeer)) {
  348.          return var1.getToolkit();
  349.       } else {
  350.          Container var2 = this.parent;
  351.          return var2 != null ? var2.getToolkitImpl() : Toolkit.getDefaultToolkit();
  352.       }
  353.    }
  354.  
  355.    public boolean isValid() {
  356.       return this.peer != null && this.valid;
  357.    }
  358.  
  359.    public boolean isDisplayable() {
  360.       return this.getPeer() != null;
  361.    }
  362.  
  363.    public boolean isVisible() {
  364.       return this.visible;
  365.    }
  366.  
  367.    boolean isRecursivelyVisible() {
  368.       return this.visible && (this.parent == null || this.parent.isRecursivelyVisible());
  369.    }
  370.  
  371.    Point pointRelativeToComponent(Point var1) {
  372.       Point var2 = this.getLocationOnScreen();
  373.       return new Point(var1.x - var2.x, var1.y - var2.y);
  374.    }
  375.  
  376.    Component findUnderMouseInWindow(PointerInfo var1) {
  377.       if (!this.isShowing()) {
  378.          return null;
  379.       } else {
  380.          Window var2 = this.getContainingWindow();
  381.          if (!Toolkit.getDefaultToolkit().getMouseInfoPeer().isWindowUnderMouse(var2)) {
  382.             return null;
  383.          } else {
  384.             Point var4 = var2.pointRelativeToComponent(var1.getLocation());
  385.             Component var5 = var2.findComponentAt(var4.x, var4.y, true);
  386.             return var5;
  387.          }
  388.       }
  389.    }
  390.  
  391.    public Point getMousePosition() throws HeadlessException {
  392.       if (GraphicsEnvironment.isHeadless()) {
  393.          throw new HeadlessException();
  394.       } else {
  395.          PointerInfo var1 = (PointerInfo)AccessController.doPrivileged(new 1(this));
  396.          synchronized(this.getTreeLock()) {
  397.             Component var3 = this.findUnderMouseInWindow(var1);
  398.             return !this.isSameOrAncestorOf(var3, true) ? null : this.pointRelativeToComponent(var1.getLocation());
  399.          }
  400.       }
  401.    }
  402.  
  403.    boolean isSameOrAncestorOf(Component var1, boolean var2) {
  404.       return var1 == this;
  405.    }
  406.  
  407.    public boolean isShowing() {
  408.       if (this.visible && this.peer != null) {
  409.          Container var1 = this.parent;
  410.          return var1 == null || var1.isShowing();
  411.       } else {
  412.          return false;
  413.       }
  414.    }
  415.  
  416.    public boolean isEnabled() {
  417.       return this.isEnabledImpl();
  418.    }
  419.  
  420.    final boolean isEnabledImpl() {
  421.       return this.enabled;
  422.    }
  423.  
  424.    public void setEnabled(boolean var1) {
  425.       this.enable(var1);
  426.    }
  427.  
  428.    /** @deprecated */
  429.    @Deprecated
  430.    public void enable() {
  431.       if (!this.enabled) {
  432.          synchronized(this.getTreeLock()) {
  433.             this.enabled = true;
  434.             ComponentPeer var2 = this.peer;
  435.             if (var2 != null) {
  436.                var2.enable();
  437.                if (this.visible) {
  438.                   this.updateCursorImmediately();
  439.                }
  440.             }
  441.          }
  442.  
  443.          if (this.accessibleContext != null) {
  444.             this.accessibleContext.firePropertyChange("AccessibleState", (Object)null, AccessibleState.ENABLED);
  445.          }
  446.       }
  447.  
  448.    }
  449.  
  450.    /** @deprecated */
  451.    @Deprecated
  452.    public void enable(boolean var1) {
  453.       if (var1) {
  454.          this.enable();
  455.       } else {
  456.          this.disable();
  457.       }
  458.  
  459.    }
  460.  
  461.    /** @deprecated */
  462.    @Deprecated
  463.    public void disable() {
  464.       if (this.enabled) {
  465.          KeyboardFocusManager.clearMostRecentFocusOwner(this);
  466.          synchronized(this.getTreeLock()) {
  467.             this.enabled = false;
  468.             if (this.isFocusOwner()) {
  469.                this.autoTransferFocus(false);
  470.             }
  471.  
  472.             ComponentPeer var2 = this.peer;
  473.             if (var2 != null) {
  474.                var2.disable();
  475.                if (this.visible) {
  476.                   this.updateCursorImmediately();
  477.                }
  478.             }
  479.          }
  480.  
  481.          if (this.accessibleContext != null) {
  482.             this.accessibleContext.firePropertyChange("AccessibleState", (Object)null, AccessibleState.ENABLED);
  483.          }
  484.       }
  485.  
  486.    }
  487.  
  488.    public boolean isDoubleBuffered() {
  489.       return false;
  490.    }
  491.  
  492.    public void enableInputMethods(boolean var1) {
  493.       if (var1) {
  494.          if ((this.eventMask & 4096L) != 0L) {
  495.             return;
  496.          }
  497.  
  498.          if (this.isFocusOwner()) {
  499.             InputContext var2 = this.getInputContext();
  500.             if (var2 != null) {
  501.                FocusEvent var3 = new FocusEvent(this, 1004);
  502.                var2.dispatchEvent(var3);
  503.             }
  504.          }
  505.  
  506.          this.eventMask |= 4096L;
  507.       } else {
  508.          if ((this.eventMask & 4096L) != 0L) {
  509.             InputContext var4 = this.getInputContext();
  510.             if (var4 != null) {
  511.                var4.endComposition();
  512.                var4.removeNotify(this);
  513.             }
  514.          }
  515.  
  516.          this.eventMask &= -4097L;
  517.       }
  518.  
  519.    }
  520.  
  521.    public void setVisible(boolean var1) {
  522.       this.show(var1);
  523.    }
  524.  
  525.    /** @deprecated */
  526.    @Deprecated
  527.    public void show() {
  528.       if (!this.visible) {
  529.          synchronized(this.getTreeLock()) {
  530.             this.visible = true;
  531.             ComponentPeer var2 = this.peer;
  532.             if (var2 != null) {
  533.                var2.show();
  534.                this.createHierarchyEvents(1400, this, this.parent, 4L, Toolkit.enabledOnToolkit(32768L));
  535.                if (var2 instanceof LightweightPeer) {
  536.                   this.repaint();
  537.                }
  538.  
  539.                this.updateCursorImmediately();
  540.             }
  541.  
  542.             if (this.componentListener != null || (this.eventMask & 1L) != 0L || Toolkit.enabledOnToolkit(1L)) {
  543.                ComponentEvent var3 = new ComponentEvent(this, 102);
  544.                Toolkit.getEventQueue().postEvent(var3);
  545.             }
  546.          }
  547.  
  548.          Container var1 = this.parent;
  549.          if (var1 != null) {
  550.             var1.invalidate();
  551.          }
  552.       }
  553.  
  554.    }
  555.  
  556.    /** @deprecated */
  557.    @Deprecated
  558.    public void show(boolean var1) {
  559.       if (var1) {
  560.          this.show();
  561.       } else {
  562.          this.hide();
  563.       }
  564.  
  565.    }
  566.  
  567.    boolean containsFocus() {
  568.       return this.isFocusOwner();
  569.    }
  570.  
  571.    void clearMostRecentFocusOwnerOnHide() {
  572.       KeyboardFocusManager.clearMostRecentFocusOwner(this);
  573.    }
  574.  
  575.    void clearCurrentFocusCycleRootOnHide() {
  576.    }
  577.  
  578.    /** @deprecated */
  579.    @Deprecated
  580.    public void hide() {
  581.       this.isPacked = false;
  582.       if (this.visible) {
  583.          this.clearCurrentFocusCycleRootOnHide();
  584.          this.clearMostRecentFocusOwnerOnHide();
  585.          synchronized(this.getTreeLock()) {
  586.             this.visible = false;
  587.             if (this.containsFocus()) {
  588.                this.autoTransferFocus(true);
  589.             }
  590.  
  591.             ComponentPeer var2 = this.peer;
  592.             if (var2 != null) {
  593.                var2.hide();
  594.                this.createHierarchyEvents(1400, this, this.parent, 4L, Toolkit.enabledOnToolkit(32768L));
  595.                if (var2 instanceof LightweightPeer) {
  596.                   this.repaint();
  597.                }
  598.  
  599.                this.updateCursorImmediately();
  600.             }
  601.  
  602.             if (this.componentListener != null || (this.eventMask & 1L) != 0L || Toolkit.enabledOnToolkit(1L)) {
  603.                ComponentEvent var3 = new ComponentEvent(this, 103);
  604.                Toolkit.getEventQueue().postEvent(var3);
  605.             }
  606.          }
  607.  
  608.          Container var1 = this.parent;
  609.          if (var1 != null) {
  610.             var1.invalidate();
  611.          }
  612.       }
  613.  
  614.    }
  615.  
  616.    public Color getForeground() {
  617.       Color var1 = this.foreground;
  618.       if (var1 != null) {
  619.          return var1;
  620.       } else {
  621.          Container var2 = this.parent;
  622.          return var2 != null ? var2.getForeground() : null;
  623.       }
  624.    }
  625.  
  626.    public void setForeground(Color var1) {
  627.       Color var2 = this.foreground;
  628.       ComponentPeer var3 = this.peer;
  629.       this.foreground = var1;
  630.       if (var3 != null) {
  631.          var1 = this.getForeground();
  632.          if (var1 != null) {
  633.             var3.setForeground(var1);
  634.          }
  635.       }
  636.  
  637.       this.firePropertyChange("foreground", var2, var1);
  638.    }
  639.  
  640.    public boolean isForegroundSet() {
  641.       return this.foreground != null;
  642.    }
  643.  
  644.    public Color getBackground() {
  645.       Color var1 = this.background;
  646.       if (var1 != null) {
  647.          return var1;
  648.       } else {
  649.          Container var2 = this.parent;
  650.          return var2 != null ? var2.getBackground() : null;
  651.       }
  652.    }
  653.  
  654.    public void setBackground(Color var1) {
  655.       Color var2 = this.background;
  656.       ComponentPeer var3 = this.peer;
  657.       this.background = var1;
  658.       if (var3 != null) {
  659.          var1 = this.getBackground();
  660.          if (var1 != null) {
  661.             var3.setBackground(var1);
  662.          }
  663.       }
  664.  
  665.       this.firePropertyChange("background", var2, var1);
  666.    }
  667.  
  668.    public boolean isBackgroundSet() {
  669.       return this.background != null;
  670.    }
  671.  
  672.    public Font getFont() {
  673.       return this.getFont_NoClientCode();
  674.    }
  675.  
  676.    final Font getFont_NoClientCode() {
  677.       Font var1 = this.font;
  678.       if (var1 != null) {
  679.          return var1;
  680.       } else {
  681.          Container var2 = this.parent;
  682.          return var2 != null ? var2.getFont_NoClientCode() : null;
  683.       }
  684.    }
  685.  
  686.    public void setFont(Font var1) {
  687.       Font var2;
  688.       Font var3;
  689.       synchronized(this.getTreeLock()) {
  690.          synchronized(this) {
  691.             var2 = this.font;
  692.             var3 = this.font = var1;
  693.          }
  694.  
  695.          ComponentPeer var5 = this.peer;
  696.          if (var5 != null) {
  697.             var1 = this.getFont();
  698.             if (var1 != null) {
  699.                var5.setFont(var1);
  700.                this.peerFont = var1;
  701.             }
  702.          }
  703.       }
  704.  
  705.       this.firePropertyChange("font", var2, var3);
  706.       if (this.valid && var1 != var2 && (var2 == null || !var2.equals(var1))) {
  707.          this.invalidate();
  708.       }
  709.  
  710.    }
  711.  
  712.    public boolean isFontSet() {
  713.       return this.font != null;
  714.    }
  715.  
  716.    public Locale getLocale() {
  717.       Locale var1 = this.locale;
  718.       if (var1 != null) {
  719.          return var1;
  720.       } else {
  721.          Container var2 = this.parent;
  722.          if (var2 == null) {
  723.             throw new IllegalComponentStateException("This component must have a parent in order to determine its locale");
  724.          } else {
  725.             return var2.getLocale();
  726.          }
  727.       }
  728.    }
  729.  
  730.    public void setLocale(Locale var1) {
  731.       Locale var2 = this.locale;
  732.       this.locale = var1;
  733.       this.firePropertyChange("locale", var2, var1);
  734.       if (this.valid) {
  735.          this.invalidate();
  736.       }
  737.  
  738.    }
  739.  
  740.    public ColorModel getColorModel() {
  741.       ComponentPeer var1 = this.peer;
  742.       if (var1 != null && !(var1 instanceof LightweightPeer)) {
  743.          return var1.getColorModel();
  744.       } else {
  745.          return GraphicsEnvironment.isHeadless() ? ColorModel.getRGBdefault() : this.getToolkit().getColorModel();
  746.       }
  747.    }
  748.  
  749.    public Point getLocation() {
  750.       return this.location();
  751.    }
  752.  
  753.    public Point getLocationOnScreen() {
  754.       synchronized(this.getTreeLock()) {
  755.          return this.getLocationOnScreen_NoTreeLock();
  756.       }
  757.    }
  758.  
  759.    final Point getLocationOnScreen_NoTreeLock() {
  760.       if (this.peer != null && this.isShowing()) {
  761.          if (!(this.peer instanceof LightweightPeer)) {
  762.             Point var4 = this.peer.getLocationOnScreen();
  763.             return var4;
  764.          } else {
  765.             Container var1 = this.getNativeContainer();
  766.             Point var2 = var1.peer.getLocationOnScreen();
  767.  
  768.             for(Object var3 = this; var3 != var1; var3 = ((Component)var3).getParent()) {
  769.                var2.x += ((Component)var3).field_0;
  770.                var2.y += ((Component)var3).field_1;
  771.             }
  772.  
  773.             return var2;
  774.          }
  775.       } else {
  776.          throw new IllegalComponentStateException("component must be showing on the screen to determine its location");
  777.       }
  778.    }
  779.  
  780.    /** @deprecated */
  781.    @Deprecated
  782.    public Point location() {
  783.       return new Point(this.field_0, this.field_1);
  784.    }
  785.  
  786.    public void setLocation(int var1, int var2) {
  787.       this.move(var1, var2);
  788.    }
  789.  
  790.    /** @deprecated */
  791.    @Deprecated
  792.    public void move(int var1, int var2) {
  793.       synchronized(this.getTreeLock()) {
  794.          this.setBoundsOp(1);
  795.          this.setBounds(var1, var2, this.width, this.height);
  796.       }
  797.    }
  798.  
  799.    public void setLocation(Point var1) {
  800.       this.setLocation(var1.x, var1.y);
  801.    }
  802.  
  803.    public Dimension getSize() {
  804.       return this.size();
  805.    }
  806.  
  807.    /** @deprecated */
  808.    @Deprecated
  809.    public Dimension size() {
  810.       return new Dimension(this.width, this.height);
  811.    }
  812.  
  813.    public void setSize(int var1, int var2) {
  814.       this.resize(var1, var2);
  815.    }
  816.  
  817.    /** @deprecated */
  818.    @Deprecated
  819.    public void resize(int var1, int var2) {
  820.       synchronized(this.getTreeLock()) {
  821.          this.setBoundsOp(2);
  822.          this.setBounds(this.field_0, this.field_1, var1, var2);
  823.       }
  824.    }
  825.  
  826.    public void setSize(Dimension var1) {
  827.       this.resize(var1);
  828.    }
  829.  
  830.    /** @deprecated */
  831.    @Deprecated
  832.    public void resize(Dimension var1) {
  833.       this.setSize(var1.width, var1.height);
  834.    }
  835.  
  836.    public Rectangle getBounds() {
  837.       return this.bounds();
  838.    }
  839.  
  840.    /** @deprecated */
  841.    @Deprecated
  842.    public Rectangle bounds() {
  843.       return new Rectangle(this.field_0, this.field_1, this.width, this.height);
  844.    }
  845.  
  846.    public void setBounds(int var1, int var2, int var3, int var4) {
  847.       this.reshape(var1, var2, var3, var4);
  848.    }
  849.  
  850.    /** @deprecated */
  851.    @Deprecated
  852.    public void reshape(int var1, int var2, int var3, int var4) {
  853.       synchronized(this.getTreeLock()) {
  854.          try {
  855.             this.setBoundsOp(3);
  856.             boolean var6 = this.width != var3 || this.height != var4;
  857.             boolean var7 = this.field_0 != var1 || this.field_1 != var2;
  858.             if (var6 || var7) {
  859.                int var8 = this.field_0;
  860.                int var9 = this.field_1;
  861.                int var10 = this.width;
  862.                int var11 = this.height;
  863.                this.field_0 = var1;
  864.                this.field_1 = var2;
  865.                this.width = var3;
  866.                this.height = var4;
  867.                if (var6) {
  868.                   this.isPacked = false;
  869.                }
  870.  
  871.                boolean var12 = true;
  872.                if (this.peer != null) {
  873.                   if (!(this.peer instanceof LightweightPeer)) {
  874.                      this.reshapeNativePeer(var1, var2, var3, var4, this.getBoundsOp());
  875.                      var6 = var10 != this.width || var11 != this.height;
  876.                      var7 = var8 != this.field_0 || var9 != this.field_1;
  877.                      if (this instanceof Window) {
  878.                         var12 = false;
  879.                      }
  880.                   }
  881.  
  882.                   if (var6) {
  883.                      this.invalidate();
  884.                   }
  885.  
  886.                   if (this.parent != null && this.parent.valid) {
  887.                      this.parent.invalidate();
  888.                   }
  889.                }
  890.  
  891.                if (var12) {
  892.                   this.notifyNewBounds(var6, var7);
  893.                }
  894.  
  895.                this.repaintParentIfNeeded(var8, var9, var10, var11);
  896.                return;
  897.             }
  898.          } finally {
  899.             this.setBoundsOp(5);
  900.          }
  901.  
  902.       }
  903.    }
  904.  
  905.    private void repaintParentIfNeeded(int var1, int var2, int var3, int var4) {
  906.       if (this.parent != null && this.peer instanceof LightweightPeer && this.isShowing()) {
  907.          this.parent.repaint(var1, var2, var3, var4);
  908.          this.repaint();
  909.       }
  910.  
  911.    }
  912.  
  913.    private void reshapeNativePeer(int var1, int var2, int var3, int var4, int var5) {
  914.       int var6 = var1;
  915.       int var7 = var2;
  916.  
  917.       for(Container var8 = this.parent; var8 != null && var8.peer instanceof LightweightPeer; var8 = var8.parent) {
  918.          var6 += var8.field_0;
  919.          var7 += var8.field_1;
  920.       }
  921.  
  922.       this.peer.setBounds(var6, var7, var3, var4, var5);
  923.    }
  924.  
  925.    private void notifyNewBounds(boolean var1, boolean var2) {
  926.       if (this.componentListener == null && (this.eventMask & 1L) == 0L && !Toolkit.enabledOnToolkit(1L)) {
  927.          if (this instanceof Container && ((Container)this).ncomponents > 0) {
  928.             boolean var5 = Toolkit.enabledOnToolkit(65536L);
  929.             if (var1) {
  930.                ((Container)this).createChildHierarchyEvents(1402, 0L, var5);
  931.             }
  932.  
  933.             if (var2) {
  934.                ((Container)this).createChildHierarchyEvents(1401, 0L, var5);
  935.             }
  936.          }
  937.       } else {
  938.          if (var1) {
  939.             ComponentEvent var3 = new ComponentEvent(this, 101);
  940.             Toolkit.getEventQueue().postEvent(var3);
  941.          }
  942.  
  943.          if (var2) {
  944.             ComponentEvent var4 = new ComponentEvent(this, 100);
  945.             Toolkit.getEventQueue().postEvent(var4);
  946.          }
  947.       }
  948.  
  949.    }
  950.  
  951.    public void setBounds(Rectangle var1) {
  952.       this.setBounds(var1.x, var1.y, var1.width, var1.height);
  953.    }
  954.  
  955.    public int getX() {
  956.       return this.field_0;
  957.    }
  958.  
  959.    public int getY() {
  960.       return this.field_1;
  961.    }
  962.  
  963.    public int getWidth() {
  964.       return this.width;
  965.    }
  966.  
  967.    public int getHeight() {
  968.       return this.height;
  969.    }
  970.  
  971.    public Rectangle getBounds(Rectangle var1) {
  972.       if (var1 == null) {
  973.          return new Rectangle(this.getX(), this.getY(), this.getWidth(), this.getHeight());
  974.       } else {
  975.          var1.setBounds(this.getX(), this.getY(), this.getWidth(), this.getHeight());
  976.          return var1;
  977.       }
  978.    }
  979.  
  980.    public Dimension getSize(Dimension var1) {
  981.       if (var1 == null) {
  982.          return new Dimension(this.getWidth(), this.getHeight());
  983.       } else {
  984.          var1.setSize(this.getWidth(), this.getHeight());
  985.          return var1;
  986.       }
  987.    }
  988.  
  989.    public Point getLocation(Point var1) {
  990.       if (var1 == null) {
  991.          return new Point(this.getX(), this.getY());
  992.       } else {
  993.          var1.setLocation(this.getX(), this.getY());
  994.          return var1;
  995.       }
  996.    }
  997.  
  998.    public boolean isOpaque() {
  999.       if (this.getPeer() == null) {
  1000.          return false;
  1001.       } else {
  1002.          return !this.isLightweight();
  1003.       }
  1004.    }
  1005.  
  1006.    public boolean isLightweight() {
  1007.       return this.getPeer() instanceof LightweightPeer;
  1008.    }
  1009.  
  1010.    public void setPreferredSize(Dimension var1) {
  1011.       Dimension var2;
  1012.       if (this.prefSizeSet) {
  1013.          var2 = this.prefSize;
  1014.       } else {
  1015.          var2 = null;
  1016.       }
  1017.  
  1018.       this.prefSize = var1;
  1019.       this.prefSizeSet = var1 != null;
  1020.       this.firePropertyChange("preferredSize", var2, var1);
  1021.    }
  1022.  
  1023.    public boolean isPreferredSizeSet() {
  1024.       return this.prefSizeSet;
  1025.    }
  1026.  
  1027.    public Dimension getPreferredSize() {
  1028.       return this.preferredSize();
  1029.    }
  1030.  
  1031.    /** @deprecated */
  1032.    @Deprecated
  1033.    public Dimension preferredSize() {
  1034.       Dimension var1 = this.prefSize;
  1035.       if (var1 == null || !this.isPreferredSizeSet() && !this.isValid()) {
  1036.          synchronized(this.getTreeLock()) {
  1037.             this.prefSize = this.peer != null ? this.peer.preferredSize() : this.getMinimumSize();
  1038.             var1 = this.prefSize;
  1039.          }
  1040.       }
  1041.  
  1042.       return new Dimension(var1);
  1043.    }
  1044.  
  1045.    public void setMinimumSize(Dimension var1) {
  1046.       Dimension var2;
  1047.       if (this.minSizeSet) {
  1048.          var2 = this.minSize;
  1049.       } else {
  1050.          var2 = null;
  1051.       }
  1052.  
  1053.       this.minSize = var1;
  1054.       this.minSizeSet = var1 != null;
  1055.       this.firePropertyChange("minimumSize", var2, var1);
  1056.    }
  1057.  
  1058.    public boolean isMinimumSizeSet() {
  1059.       return this.minSizeSet;
  1060.    }
  1061.  
  1062.    public Dimension getMinimumSize() {
  1063.       return this.minimumSize();
  1064.    }
  1065.  
  1066.    /** @deprecated */
  1067.    @Deprecated
  1068.    public Dimension minimumSize() {
  1069.       Dimension var1 = this.minSize;
  1070.       if (var1 == null || !this.isMinimumSizeSet() && !this.isValid()) {
  1071.          synchronized(this.getTreeLock()) {
  1072.             this.minSize = this.peer != null ? this.peer.minimumSize() : this.size();
  1073.             var1 = this.minSize;
  1074.          }
  1075.       }
  1076.  
  1077.       return new Dimension(var1);
  1078.    }
  1079.  
  1080.    public void setMaximumSize(Dimension var1) {
  1081.       Dimension var2;
  1082.       if (this.maxSizeSet) {
  1083.          var2 = this.maxSize;
  1084.       } else {
  1085.          var2 = null;
  1086.       }
  1087.  
  1088.       this.maxSize = var1;
  1089.       this.maxSizeSet = var1 != null;
  1090.       this.firePropertyChange("maximumSize", var2, var1);
  1091.    }
  1092.  
  1093.    public boolean isMaximumSizeSet() {
  1094.       return this.maxSizeSet;
  1095.    }
  1096.  
  1097.    public Dimension getMaximumSize() {
  1098.       return this.isMaximumSizeSet() ? new Dimension(this.maxSize) : new Dimension(32767, 32767);
  1099.    }
  1100.  
  1101.    public float getAlignmentX() {
  1102.       return 0.5F;
  1103.    }
  1104.  
  1105.    public float getAlignmentY() {
  1106.       return 0.5F;
  1107.    }
  1108.  
  1109.    public int getBaseline(int var1, int var2) {
  1110.       if (var1 >= 0 && var2 >= 0) {
  1111.          return -1;
  1112.       } else {
  1113.          throw new IllegalArgumentException("Width and height must be >= 0");
  1114.       }
  1115.    }
  1116.  
  1117.    public BaselineResizeBehavior getBaselineResizeBehavior() {
  1118.       return java.awt.Component.BaselineResizeBehavior.OTHER;
  1119.    }
  1120.  
  1121.    public void doLayout() {
  1122.       this.layout();
  1123.    }
  1124.  
  1125.    /** @deprecated */
  1126.    @Deprecated
  1127.    public void layout() {
  1128.    }
  1129.  
  1130.    public void validate() {
  1131.       if (!this.valid) {
  1132.          synchronized(this.getTreeLock()) {
  1133.             ComponentPeer var2 = this.peer;
  1134.             if (!this.valid && var2 != null) {
  1135.                Font var3 = this.getFont();
  1136.                Font var4 = this.peerFont;
  1137.                if (var3 != var4 && (var4 == null || !var4.equals(var3))) {
  1138.                   var2.setFont(var3);
  1139.                   this.peerFont = var3;
  1140.                }
  1141.  
  1142.                var2.layout();
  1143.             }
  1144.          }
  1145.  
  1146.          this.valid = true;
  1147.       }
  1148.  
  1149.    }
  1150.  
  1151.    public void invalidate() {
  1152.       synchronized(this.getTreeLock()) {
  1153.          this.valid = false;
  1154.          if (!this.isPreferredSizeSet()) {
  1155.             this.prefSize = null;
  1156.          }
  1157.  
  1158.          if (!this.isMinimumSizeSet()) {
  1159.             this.minSize = null;
  1160.          }
  1161.  
  1162.          if (!this.isMaximumSizeSet()) {
  1163.             this.maxSize = null;
  1164.          }
  1165.  
  1166.          if (this.parent != null && this.parent.valid) {
  1167.             this.parent.invalidate();
  1168.          }
  1169.  
  1170.       }
  1171.    }
  1172.  
  1173.    public Graphics getGraphics() {
  1174.       if (this.peer instanceof LightweightPeer) {
  1175.          if (this.parent == null) {
  1176.             return null;
  1177.          } else {
  1178.             Graphics var2 = this.parent.getGraphics();
  1179.             if (var2 == null) {
  1180.                return null;
  1181.             } else {
  1182.                if (var2 instanceof ConstrainableGraphics) {
  1183.                   ((ConstrainableGraphics)var2).constrain(this.field_0, this.field_1, this.width, this.height);
  1184.                } else {
  1185.                   var2.translate(this.field_0, this.field_1);
  1186.                   var2.setClip(0, 0, this.width, this.height);
  1187.                }
  1188.  
  1189.                var2.setFont(this.getFont());
  1190.                return var2;
  1191.             }
  1192.          }
  1193.       } else {
  1194.          ComponentPeer var1 = this.peer;
  1195.          return var1 != null ? var1.getGraphics() : null;
  1196.       }
  1197.    }
  1198.  
  1199.    final Graphics getGraphics_NoClientCode() {
  1200.       ComponentPeer var1 = this.peer;
  1201.       if (var1 instanceof LightweightPeer) {
  1202.          Container var2 = this.parent;
  1203.          if (var2 == null) {
  1204.             return null;
  1205.          } else {
  1206.             Graphics var3 = var2.getGraphics_NoClientCode();
  1207.             if (var3 == null) {
  1208.                return null;
  1209.             } else {
  1210.                if (var3 instanceof ConstrainableGraphics) {
  1211.                   ((ConstrainableGraphics)var3).constrain(this.field_0, this.field_1, this.width, this.height);
  1212.                } else {
  1213.                   var3.translate(this.field_0, this.field_1);
  1214.                   var3.setClip(0, 0, this.width, this.height);
  1215.                }
  1216.  
  1217.                var3.setFont(this.getFont_NoClientCode());
  1218.                return var3;
  1219.             }
  1220.          }
  1221.       } else {
  1222.          return var1 != null ? var1.getGraphics() : null;
  1223.       }
  1224.    }
  1225.  
  1226.    public FontMetrics getFontMetrics(Font var1) {
  1227.       return (FontMetrics)(FontManager.usePlatformFontMetrics() && this.peer != null && !(this.peer instanceof LightweightPeer) ? this.peer.getFontMetrics(var1) : FontDesignMetrics.getMetrics(var1));
  1228.    }
  1229.  
  1230.    public void setCursor(Cursor var1) {
  1231.       this.cursor = var1;
  1232.       this.updateCursorImmediately();
  1233.    }
  1234.  
  1235.    final void updateCursorImmediately() {
  1236.       if (this.peer instanceof LightweightPeer) {
  1237.          Container var1 = this.getNativeContainer();
  1238.          if (var1 == null) {
  1239.             return;
  1240.          }
  1241.  
  1242.          ComponentPeer var2 = var1.getPeer();
  1243.          if (var2 != null) {
  1244.             var2.updateCursorImmediately();
  1245.          }
  1246.       } else if (this.peer != null) {
  1247.          this.peer.updateCursorImmediately();
  1248.       }
  1249.  
  1250.    }
  1251.  
  1252.    public Cursor getCursor() {
  1253.       Cursor var1 = this.cursor;
  1254.       if (var1 != null) {
  1255.          return var1;
  1256.       } else {
  1257.          Container var2 = this.parent;
  1258.          return var2 != null ? var2.getCursor() : Cursor.getPredefinedCursor(0);
  1259.       }
  1260.    }
  1261.  
  1262.    public boolean isCursorSet() {
  1263.       return this.cursor != null;
  1264.    }
  1265.  
  1266.    public void paint(Graphics var1) {
  1267.    }
  1268.  
  1269.    public void update(Graphics var1) {
  1270.       this.paint(var1);
  1271.    }
  1272.  
  1273.    public void paintAll(Graphics var1) {
  1274.       if (this.isShowing()) {
  1275.          PeerPaintCallback.getInstance().runOneComponent(this, new Rectangle(0, 0, this.width, this.height), var1, var1.getClip(), 3);
  1276.       }
  1277.  
  1278.    }
  1279.  
  1280.    void lightweightPaint(Graphics var1) {
  1281.       this.paint(var1);
  1282.    }
  1283.  
  1284.    void paintHeavyweightComponents(Graphics var1) {
  1285.    }
  1286.  
  1287.    public void repaint() {
  1288.       this.repaint(0L, 0, 0, this.width, this.height);
  1289.    }
  1290.  
  1291.    public void repaint(long var1) {
  1292.       this.repaint(var1, 0, 0, this.width, this.height);
  1293.    }
  1294.  
  1295.    public void repaint(int var1, int var2, int var3, int var4) {
  1296.       this.repaint(0L, var1, var2, var3, var4);
  1297.    }
  1298.  
  1299.    public void repaint(long var1, int var3, int var4, int var5, int var6) {
  1300.       if (this.peer instanceof LightweightPeer) {
  1301.          if (this.parent != null) {
  1302.             int var7 = this.field_0 + (var3 < 0 ? 0 : var3);
  1303.             int var8 = this.field_1 + (var4 < 0 ? 0 : var4);
  1304.             int var9 = var5 > this.width ? this.width : var5;
  1305.             int var10 = var6 > this.height ? this.height : var6;
  1306.             this.parent.repaint(var1, var7, var8, var9, var10);
  1307.          }
  1308.       } else if (this.isVisible() && this.peer != null && var5 > 0 && var6 > 0) {
  1309.          PaintEvent var11 = new PaintEvent(this, 801, new Rectangle(var3, var4, var5, var6));
  1310.          Toolkit.getEventQueue().postEvent(var11);
  1311.       }
  1312.  
  1313.    }
  1314.  
  1315.    public void print(Graphics var1) {
  1316.       this.paint(var1);
  1317.    }
  1318.  
  1319.    public void printAll(Graphics var1) {
  1320.       if (this.isShowing()) {
  1321.          PeerPrintCallback.getInstance().runOneComponent(this, new Rectangle(0, 0, this.width, this.height), var1, var1.getClip(), 3);
  1322.       }
  1323.  
  1324.    }
  1325.  
  1326.    void lightweightPrint(Graphics var1) {
  1327.       this.print(var1);
  1328.    }
  1329.  
  1330.    void printHeavyweightComponents(Graphics var1) {
  1331.    }
  1332.  
  1333.    private Insets getInsets_NoClientCode() {
  1334.       ComponentPeer var1 = this.peer;
  1335.       return var1 instanceof ContainerPeer ? (Insets)((ContainerPeer)var1).insets().clone() : new Insets(0, 0, 0, 0);
  1336.    }
  1337.  
  1338.    public boolean imageUpdate(Image var1, int var2, int var3, int var4, int var5, int var6) {
  1339.       int var7 = -1;
  1340.       if ((var2 & 48) != 0) {
  1341.          var7 = 0;
  1342.       } else if ((var2 & 8) != 0 && isInc) {
  1343.          var7 = incRate;
  1344.          if (var7 < 0) {
  1345.             var7 = 0;
  1346.          }
  1347.       }
  1348.  
  1349.       if (var7 >= 0) {
  1350.          this.repaint((long)var7, 0, 0, this.width, this.height);
  1351.       }
  1352.  
  1353.       return (var2 & 160) == 0;
  1354.    }
  1355.  
  1356.    public Image createImage(ImageProducer var1) {
  1357.       ComponentPeer var2 = this.peer;
  1358.       return var2 != null && !(var2 instanceof LightweightPeer) ? var2.createImage(var1) : this.getToolkit().createImage(var1);
  1359.    }
  1360.  
  1361.    public Image createImage(int var1, int var2) {
  1362.       ComponentPeer var3 = this.peer;
  1363.       if (var3 instanceof LightweightPeer) {
  1364.          return this.parent != null ? this.parent.createImage(var1, var2) : null;
  1365.       } else {
  1366.          return var3 != null ? var3.createImage(var1, var2) : null;
  1367.       }
  1368.    }
  1369.  
  1370.    public VolatileImage createVolatileImage(int var1, int var2) {
  1371.       ComponentPeer var3 = this.peer;
  1372.       if (var3 instanceof LightweightPeer) {
  1373.          return this.parent != null ? this.parent.createVolatileImage(var1, var2) : null;
  1374.       } else {
  1375.          return var3 != null ? var3.createVolatileImage(var1, var2) : null;
  1376.       }
  1377.    }
  1378.  
  1379.    public VolatileImage createVolatileImage(int var1, int var2, ImageCapabilities var3) throws AWTException {
  1380.       return this.createVolatileImage(var1, var2);
  1381.    }
  1382.  
  1383.    public boolean prepareImage(Image var1, ImageObserver var2) {
  1384.       return this.prepareImage(var1, -1, -1, var2);
  1385.    }
  1386.  
  1387.    public boolean prepareImage(Image var1, int var2, int var3, ImageObserver var4) {
  1388.       ComponentPeer var5 = this.peer;
  1389.       if (var5 instanceof LightweightPeer) {
  1390.          return this.parent != null ? this.parent.prepareImage(var1, var2, var3, var4) : this.getToolkit().prepareImage(var1, var2, var3, var4);
  1391.       } else {
  1392.          return var5 != null ? var5.prepareImage(var1, var2, var3, var4) : this.getToolkit().prepareImage(var1, var2, var3, var4);
  1393.       }
  1394.    }
  1395.  
  1396.    public int checkImage(Image var1, ImageObserver var2) {
  1397.       return this.checkImage(var1, -1, -1, var2);
  1398.    }
  1399.  
  1400.    public int checkImage(Image var1, int var2, int var3, ImageObserver var4) {
  1401.       ComponentPeer var5 = this.peer;
  1402.       if (var5 instanceof LightweightPeer) {
  1403.          return this.parent != null ? this.parent.checkImage(var1, var2, var3, var4) : this.getToolkit().checkImage(var1, var2, var3, var4);
  1404.       } else {
  1405.          return var5 != null ? var5.checkImage(var1, var2, var3, var4) : this.getToolkit().checkImage(var1, var2, var3, var4);
  1406.       }
  1407.    }
  1408.  
  1409.    void createBufferStrategy(int var1) {
  1410.       if (var1 > 1) {
  1411.          BufferCapabilities var2 = new BufferCapabilities(new ImageCapabilities(true), new ImageCapabilities(true), FlipContents.UNDEFINED);
  1412.  
  1413.          try {
  1414.             this.createBufferStrategy(var1, var2);
  1415.             return;
  1416.          } catch (AWTException var6) {
  1417.          }
  1418.       }
  1419.  
  1420.       BufferCapabilities var7 = new BufferCapabilities(new ImageCapabilities(true), new ImageCapabilities(true), (BufferCapabilities.FlipContents)null);
  1421.  
  1422.       try {
  1423.          this.createBufferStrategy(var1, var7);
  1424.       } catch (AWTException var5) {
  1425.          var7 = new BufferCapabilities(new ImageCapabilities(false), new ImageCapabilities(false), (BufferCapabilities.FlipContents)null);
  1426.  
  1427.          try {
  1428.             this.createBufferStrategy(var1, var7);
  1429.          } catch (AWTException var4) {
  1430.             throw new InternalError("Could not create a buffer strategy");
  1431.          }
  1432.       }
  1433.    }
  1434.  
  1435.    void createBufferStrategy(int var1, BufferCapabilities var2) throws AWTException {
  1436.       if (var1 < 1) {
  1437.          throw new IllegalArgumentException("Number of buffers must be at least 1");
  1438.       } else if (var2 == null) {
  1439.          throw new IllegalArgumentException("No capabilities specified");
  1440.       } else {
  1441.          if (this.bufferStrategy != null) {
  1442.             this.bufferStrategy.dispose();
  1443.          }
  1444.  
  1445.          if (var1 == 1) {
  1446.             this.bufferStrategy = new SingleBufferStrategy(this, var2);
  1447.          } else if (var2.isPageFlipping()) {
  1448.             this.bufferStrategy = new FlipSubRegionBufferStrategy(this, var1, var2);
  1449.          } else {
  1450.             this.bufferStrategy = new BltSubRegionBufferStrategy(this, var1, var2);
  1451.          }
  1452.  
  1453.       }
  1454.    }
  1455.  
  1456.    BufferStrategy getBufferStrategy() {
  1457.       return this.bufferStrategy;
  1458.    }
  1459.  
  1460.    Image getBackBuffer() {
  1461.       if (this.bufferStrategy != null) {
  1462.          if (this.bufferStrategy instanceof BltBufferStrategy) {
  1463.             BltBufferStrategy var2 = (BltBufferStrategy)this.bufferStrategy;
  1464.             return var2.getBackBuffer();
  1465.          }
  1466.  
  1467.          if (this.bufferStrategy instanceof FlipBufferStrategy) {
  1468.             FlipBufferStrategy var1 = (FlipBufferStrategy)this.bufferStrategy;
  1469.             return var1.getBackBuffer();
  1470.          }
  1471.       }
  1472.  
  1473.       return null;
  1474.    }
  1475.  
  1476.    public void setIgnoreRepaint(boolean var1) {
  1477.       this.ignoreRepaint = var1;
  1478.    }
  1479.  
  1480.    public boolean getIgnoreRepaint() {
  1481.       return this.ignoreRepaint;
  1482.    }
  1483.  
  1484.    public boolean contains(int var1, int var2) {
  1485.       return this.inside(var1, var2);
  1486.    }
  1487.  
  1488.    /** @deprecated */
  1489.    @Deprecated
  1490.    public boolean inside(int var1, int var2) {
  1491.       return var1 >= 0 && var1 < this.width && var2 >= 0 && var2 < this.height;
  1492.    }
  1493.  
  1494.    public boolean contains(Point var1) {
  1495.       return this.contains(var1.x, var1.y);
  1496.    }
  1497.  
  1498.    public Component getComponentAt(int var1, int var2) {
  1499.       return this.locate(var1, var2);
  1500.    }
  1501.  
  1502.    /** @deprecated */
  1503.    @Deprecated
  1504.    public Component locate(int var1, int var2) {
  1505.       return this.contains(var1, var2) ? this : null;
  1506.    }
  1507.  
  1508.    public Component getComponentAt(Point var1) {
  1509.       return this.getComponentAt(var1.x, var1.y);
  1510.    }
  1511.  
  1512.    /** @deprecated */
  1513.    @Deprecated
  1514.    public void deliverEvent(Event var1) {
  1515.       this.postEvent(var1);
  1516.    }
  1517.  
  1518.    public final void dispatchEvent(AWTEvent var1) {
  1519.       this.dispatchEventImpl(var1);
  1520.    }
  1521.  
  1522.    void dispatchEventImpl(AWTEvent var1) {
  1523.       int var2 = var1.getID();
  1524.       AppContext var3 = this.appContext;
  1525.       if (var3 != null && !var3.equals(AppContext.getAppContext())) {
  1526.          log.fine("Event " + var1 + " is being dispatched on the wrong AppContext");
  1527.       }
  1528.  
  1529.       if (log.isLoggable(Level.FINEST)) {
  1530.          log.log(Level.FINEST, "{0}", var1);
  1531.       }
  1532.  
  1533.       EventQueue.setCurrentEventAndMostRecentTime(var1);
  1534.       if (var1 instanceof SunDropTargetEvent) {
  1535.          ((SunDropTargetEvent)var1).dispatch();
  1536.       } else {
  1537.          if (!var1.focusManagerIsDispatching) {
  1538.             if (var1.isPosted) {
  1539.                var1 = KeyboardFocusManager.retargetFocusEvent(var1);
  1540.                var1.isPosted = true;
  1541.             }
  1542.  
  1543.             if (KeyboardFocusManager.getCurrentKeyboardFocusManager().dispatchEvent(var1)) {
  1544.                return;
  1545.             }
  1546.          }
  1547.  
  1548.          if (var1 instanceof FocusEvent && focusLog.isLoggable(Level.FINE)) {
  1549.             focusLog.fine("" + var1);
  1550.          }
  1551.  
  1552.          if (var2 != 507 || this.eventTypeEnabled(var2) || this.peer == null || this.peer.handlesWheelScrolling() || !this.dispatchMouseWheelToAncestor((MouseWheelEvent)var1)) {
  1553.             Toolkit var4 = Toolkit.getDefaultToolkit();
  1554.             var4.notifyAWTEventListeners(var1);
  1555.             if (!var1.isConsumed() && var1 instanceof KeyEvent) {
  1556.                KeyboardFocusManager.getCurrentKeyboardFocusManager().processKeyEvent(this, (KeyEvent)var1);
  1557.                if (var1.isConsumed()) {
  1558.                   return;
  1559.                }
  1560.             }
  1561.  
  1562.             if (this.areInputMethodsEnabled()) {
  1563.                if (var1 instanceof InputMethodEvent && !(this instanceof CompositionArea) || var1 instanceof InputEvent || var1 instanceof FocusEvent) {
  1564.                   InputContext var5 = this.getInputContext();
  1565.                   if (var5 != null) {
  1566.                      var5.dispatchEvent(var1);
  1567.                      if (var1.isConsumed()) {
  1568.                         if (var1 instanceof FocusEvent && focusLog.isLoggable(Level.FINER)) {
  1569.                            focusLog.finer("3579: Skipping " + var1);
  1570.                         }
  1571.  
  1572.                         return;
  1573.                      }
  1574.                   }
  1575.                }
  1576.             } else if (var2 == 1004) {
  1577.                InputContext var8 = this.getInputContext();
  1578.                if (var8 != null && var8 instanceof sun.awt.im.InputContext) {
  1579.                   ((sun.awt.im.InputContext)var8).disableNativeIM();
  1580.                }
  1581.             }
  1582.  
  1583.             switch (var2) {
  1584.                case 201:
  1585.                   if (var4 instanceof WindowClosingListener) {
  1586.                      this.windowClosingException = ((WindowClosingListener)var4).windowClosingNotify((WindowEvent)var1);
  1587.                      if (this.checkWindowClosingException()) {
  1588.                         return;
  1589.                      }
  1590.                   }
  1591.                   break;
  1592.                case 401:
  1593.                case 402:
  1594.                   Container var9 = (Container)(this instanceof Container ? this : this.parent);
  1595.                   if (var9 != null) {
  1596.                      var9.preProcessKeyEvent((KeyEvent)var1);
  1597.                      if (var1.isConsumed()) {
  1598.                         if (focusLog.isLoggable(Level.FINEST)) {
  1599.                            focusLog.finest("Pre-process consumed event");
  1600.                         }
  1601.  
  1602.                         return;
  1603.                      }
  1604.                   }
  1605.             }
  1606.  
  1607.             if (this.newEventsOnly) {
  1608.                if (this.eventEnabled(var1)) {
  1609.                   this.processEvent(var1);
  1610.                }
  1611.             } else if (var2 == 507) {
  1612.                this.autoProcessMouseWheel((MouseWheelEvent)var1);
  1613.             } else if (!(var1 instanceof MouseEvent) || this.postsOldMouseEvents()) {
  1614.                Event var10 = var1.convertToOld();
  1615.                if (var10 != null) {
  1616.                   int var6 = var10.key;
  1617.                   int var7 = var10.modifiers;
  1618.                   this.postEvent(var10);
  1619.                   if (var10.isConsumed()) {
  1620.                      var1.consume();
  1621.                   }
  1622.  
  1623.                   switch (var10.id) {
  1624.                      case 401:
  1625.                      case 402:
  1626.                      case 403:
  1627.                      case 404:
  1628.                         if (var10.key != var6) {
  1629.                            ((KeyEvent)var1).setKeyChar(var10.getKeyEventChar());
  1630.                         }
  1631.  
  1632.                         if (var10.modifiers != var7) {
  1633.                            ((KeyEvent)var1).setModifiers(var10.modifiers);
  1634.                         }
  1635.                   }
  1636.                }
  1637.             }
  1638.  
  1639.             if (var2 == 201 && !var1.isConsumed() && var4 instanceof WindowClosingListener) {
  1640.                this.windowClosingException = ((WindowClosingListener)var4).windowClosingDelivered((WindowEvent)var1);
  1641.                if (this.checkWindowClosingException()) {
  1642.                   return;
  1643.                }
  1644.             }
  1645.  
  1646.             if (!(var1 instanceof KeyEvent)) {
  1647.                ComponentPeer var11 = this.peer;
  1648.                if (var1 instanceof FocusEvent && (var11 == null || var11 instanceof LightweightPeer)) {
  1649.                   Component var12 = (Component)var1.getSource();
  1650.                   if (var12 != null) {
  1651.                      Container var13 = var12.getNativeContainer();
  1652.                      if (var13 != null) {
  1653.                         var11 = var13.getPeer();
  1654.                      }
  1655.                   }
  1656.                }
  1657.  
  1658.                if (var11 != null) {
  1659.                   var11.handleEvent(var1);
  1660.                }
  1661.             }
  1662.  
  1663.          }
  1664.       }
  1665.    }
  1666.  
  1667.    void autoProcessMouseWheel(MouseWheelEvent var1) {
  1668.    }
  1669.  
  1670.    boolean dispatchMouseWheelToAncestor(MouseWheelEvent var1) {
  1671.       int var2 = var1.getX() + this.getX();
  1672.       int var3 = var1.getY() + this.getY();
  1673.       DebugHelper var10000 = dbg;
  1674.       synchronized(this.getTreeLock()) {
  1675.          Container var6;
  1676.          for(var6 = this.getParent(); var6 != null && !var6.eventEnabled(var1); var6 = var6.getParent()) {
  1677.             var2 += var6.getX();
  1678.             var3 += var6.getY();
  1679.             if (var6 instanceof Window) {
  1680.                break;
  1681.             }
  1682.          }
  1683.  
  1684.          var10000 = dbg;
  1685.          if (var6 != null && var6.eventEnabled(var1)) {
  1686.             MouseWheelEvent var4 = new MouseWheelEvent(var6, var1.getID(), var1.getWhen(), var1.getModifiers(), var2, var3, var1.getXOnScreen(), var1.getYOnScreen(), var1.getClickCount(), var1.isPopupTrigger(), var1.getScrollType(), var1.getScrollAmount(), var1.getWheelRotation());
  1687.             ((AWTEvent)var1).copyPrivateDataInto(var4);
  1688.             var6.dispatchEventImpl(var4);
  1689.          }
  1690.  
  1691.          return true;
  1692.       }
  1693.    }
  1694.  
  1695.    boolean checkWindowClosingException() {
  1696.       if (this.windowClosingException != null) {
  1697.          if (this instanceof Dialog) {
  1698.             ((Dialog)this).interruptBlocking();
  1699.          } else {
  1700.             this.windowClosingException.fillInStackTrace();
  1701.             this.windowClosingException.printStackTrace();
  1702.             this.windowClosingException = null;
  1703.          }
  1704.  
  1705.          return true;
  1706.       } else {
  1707.          return false;
  1708.       }
  1709.    }
  1710.  
  1711.    boolean areInputMethodsEnabled() {
  1712.       return (this.eventMask & 4096L) != 0L && ((this.eventMask & 8L) != 0L || this.keyListener != null);
  1713.    }
  1714.  
  1715.    boolean eventEnabled(AWTEvent var1) {
  1716.       return this.eventTypeEnabled(var1.id);
  1717.    }
  1718.  
  1719.    boolean eventTypeEnabled(int var1) {
  1720.       switch (var1) {
  1721.          case 100:
  1722.          case 101:
  1723.          case 102:
  1724.          case 103:
  1725.             if ((this.eventMask & 1L) != 0L || this.componentListener != null) {
  1726.                return true;
  1727.             }
  1728.             break;
  1729.          case 400:
  1730.          case 401:
  1731.          case 402:
  1732.             if ((this.eventMask & 8L) != 0L || this.keyListener != null) {
  1733.                return true;
  1734.             }
  1735.             break;
  1736.          case 500:
  1737.          case 501:
  1738.          case 502:
  1739.          case 504:
  1740.          case 505:
  1741.             if ((this.eventMask & 16L) != 0L || this.mouseListener != null) {
  1742.                return true;
  1743.             }
  1744.             break;
  1745.          case 503:
  1746.          case 506:
  1747.             if ((this.eventMask & 32L) != 0L || this.mouseMotionListener != null) {
  1748.                return true;
  1749.             }
  1750.             break;
  1751.          case 507:
  1752.             if ((this.eventMask & 131072L) != 0L || this.mouseWheelListener != null) {
  1753.                return true;
  1754.             }
  1755.             break;
  1756.          case 601:
  1757.             if ((this.eventMask & 256L) != 0L) {
  1758.                return true;
  1759.             }
  1760.             break;
  1761.          case 701:
  1762.             if ((this.eventMask & 512L) != 0L) {
  1763.                return true;
  1764.             }
  1765.             break;
  1766.          case 900:
  1767.             if ((this.eventMask & 1024L) != 0L) {
  1768.                return true;
  1769.             }
  1770.             break;
  1771.          case 1001:
  1772.             if ((this.eventMask & 128L) != 0L) {
  1773.                return true;
  1774.             }
  1775.             break;
  1776.          case 1004:
  1777.          case 1005:
  1778.             if ((this.eventMask & 4L) != 0L || this.focusListener != null) {
  1779.                return true;
  1780.             }
  1781.             break;
  1782.          case 1100:
  1783.          case 1101:
  1784.             if ((this.eventMask & 2048L) != 0L || this.inputMethodListener != null) {
  1785.                return true;
  1786.             }
  1787.             break;
  1788.          case 1400:
  1789.             if ((this.eventMask & 32768L) != 0L || this.hierarchyListener != null) {
  1790.                return true;
  1791.             }
  1792.             break;
  1793.          case 1401:
  1794.          case 1402:
  1795.             if ((this.eventMask & 65536L) != 0L || this.hierarchyBoundsListener != null) {
  1796.                return true;
  1797.             }
  1798.       }
  1799.  
  1800.       if (var1 > 1999) {
  1801.          return true;
  1802.       } else {
  1803.          return false;
  1804.       }
  1805.    }
  1806.  
  1807.    /** @deprecated */
  1808.    @Deprecated
  1809.    public boolean postEvent(Event var1) {
  1810.       ComponentPeer var2 = this.peer;
  1811.       if (this.handleEvent(var1)) {
  1812.          var1.consume();
  1813.          return true;
  1814.       } else {
  1815.          Container var3 = this.parent;
  1816.          int var4 = var1.x;
  1817.          int var5 = var1.y;
  1818.          if (var3 != null) {
  1819.             var1.translate(this.field_0, this.field_1);
  1820.             if (((Component)var3).postEvent(var1)) {
  1821.                var1.consume();
  1822.                return true;
  1823.             }
  1824.  
  1825.             var1.x = var4;
  1826.             var1.y = var5;
  1827.          }
  1828.  
  1829.          return false;
  1830.       }
  1831.    }
  1832.  
  1833.    public synchronized void addComponentListener(ComponentListener var1) {
  1834.       if (var1 != null) {
  1835.          this.componentListener = AWTEventMulticaster.add(this.componentListener, var1);
  1836.          this.newEventsOnly = true;
  1837.       }
  1838.    }
  1839.  
  1840.    public synchronized void removeComponentListener(ComponentListener var1) {
  1841.       if (var1 != null) {
  1842.          this.componentListener = AWTEventMulticaster.remove(this.componentListener, var1);
  1843.       }
  1844.    }
  1845.  
  1846.    public synchronized ComponentListener[] getComponentListeners() {
  1847.       return (ComponentListener[])this.getListeners(ComponentListener.class);
  1848.    }
  1849.  
  1850.    public synchronized void addFocusListener(FocusListener var1) {
  1851.       if (var1 != null) {
  1852.          this.focusListener = AWTEventMulticaster.add(this.focusListener, var1);
  1853.          this.newEventsOnly = true;
  1854.          if (this.peer instanceof LightweightPeer) {
  1855.             this.parent.proxyEnableEvents(4L);
  1856.          }
  1857.  
  1858.       }
  1859.    }
  1860.  
  1861.    public synchronized void removeFocusListener(FocusListener var1) {
  1862.       if (var1 != null) {
  1863.          this.focusListener = AWTEventMulticaster.remove(this.focusListener, var1);
  1864.       }
  1865.    }
  1866.  
  1867.    public synchronized FocusListener[] getFocusListeners() {
  1868.       return (FocusListener[])this.getListeners(FocusListener.class);
  1869.    }
  1870.  
  1871.    public void addHierarchyListener(HierarchyListener var1) {
  1872.       if (var1 != null) {
  1873.          boolean var8;
  1874.          synchronized(this) {
  1875.             var8 = this.hierarchyListener == null && (this.eventMask & 32768L) == 0L;
  1876.             this.hierarchyListener = AWTEventMulticaster.add(this.hierarchyListener, var1);
  1877.             var8 = var8 && this.hierarchyListener != null;
  1878.             this.newEventsOnly = true;
  1879.          }
  1880.  
  1881.          if (var8) {
  1882.             synchronized(this.getTreeLock()) {
  1883.                this.adjustListeningChildrenOnParent(32768L, 1);
  1884.             }
  1885.          }
  1886.  
  1887.       }
  1888.    }
  1889.  
  1890.    public void removeHierarchyListener(HierarchyListener var1) {
  1891.       if (var1 != null) {
  1892.          boolean var8;
  1893.          synchronized(this) {
  1894.             var8 = this.hierarchyListener != null && (this.eventMask & 32768L) == 0L;
  1895.             this.hierarchyListener = AWTEventMulticaster.remove(this.hierarchyListener, var1);
  1896.             var8 = var8 && this.hierarchyListener == null;
  1897.          }
  1898.  
  1899.          if (var8) {
  1900.             synchronized(this.getTreeLock()) {
  1901.                this.adjustListeningChildrenOnParent(32768L, -1);
  1902.             }
  1903.          }
  1904.  
  1905.       }
  1906.    }
  1907.  
  1908.    public synchronized HierarchyListener[] getHierarchyListeners() {
  1909.       return (HierarchyListener[])this.getListeners(HierarchyListener.class);
  1910.    }
  1911.  
  1912.    public void addHierarchyBoundsListener(HierarchyBoundsListener var1) {
  1913.       if (var1 != null) {
  1914.          boolean var8;
  1915.          synchronized(this) {
  1916.             var8 = this.hierarchyBoundsListener == null && (this.eventMask & 65536L) == 0L;
  1917.             this.hierarchyBoundsListener = AWTEventMulticaster.add(this.hierarchyBoundsListener, var1);
  1918.             var8 = var8 && this.hierarchyBoundsListener != null;
  1919.             this.newEventsOnly = true;
  1920.          }
  1921.  
  1922.          if (var8) {
  1923.             synchronized(this.getTreeLock()) {
  1924.                this.adjustListeningChildrenOnParent(65536L, 1);
  1925.             }
  1926.          }
  1927.  
  1928.       }
  1929.    }
  1930.  
  1931.    public void removeHierarchyBoundsListener(HierarchyBoundsListener var1) {
  1932.       if (var1 != null) {
  1933.          boolean var8;
  1934.          synchronized(this) {
  1935.             var8 = this.hierarchyBoundsListener != null && (this.eventMask & 65536L) == 0L;
  1936.             this.hierarchyBoundsListener = AWTEventMulticaster.remove(this.hierarchyBoundsListener, var1);
  1937.             var8 = var8 && this.hierarchyBoundsListener == null;
  1938.          }
  1939.  
  1940.          if (var8) {
  1941.             synchronized(this.getTreeLock()) {
  1942.                this.adjustListeningChildrenOnParent(65536L, -1);
  1943.             }
  1944.          }
  1945.  
  1946.       }
  1947.    }
  1948.  
  1949.    int numListening(long var1) {
  1950.       DebugHelper var10000 = dbg;
  1951.       return (var1 != 32768L || this.hierarchyListener == null && (this.eventMask & 32768L) == 0L) && (var1 != 65536L || this.hierarchyBoundsListener == null && (this.eventMask & 65536L) == 0L) ? 0 : 1;
  1952.    }
  1953.  
  1954.    int countHierarchyMembers() {
  1955.       return 1;
  1956.    }
  1957.  
  1958.    int createHierarchyEvents(int var1, Component var2, Container var3, long var4, boolean var6) {
  1959.       switch (var1) {
  1960.          case 1400:
  1961.             if (this.hierarchyListener != null || (this.eventMask & 32768L) != 0L || var6) {
  1962.                HierarchyEvent var8 = new HierarchyEvent(this, var1, var2, var3, var4);
  1963.                this.dispatchEvent(var8);
  1964.                return 1;
  1965.             }
  1966.             break;
  1967.          case 1401:
  1968.          case 1402:
  1969.             DebugHelper var10000 = dbg;
  1970.             if (this.hierarchyBoundsListener != null || (this.eventMask & 65536L) != 0L || var6) {
  1971.                HierarchyEvent var7 = new HierarchyEvent(this, var1, var2, var3);
  1972.                this.dispatchEvent(var7);
  1973.                return 1;
  1974.             }
  1975.             break;
  1976.          default:
  1977.             DebugHelper var9 = dbg;
  1978.       }
  1979.  
  1980.       return 0;
  1981.    }
  1982.  
  1983.    public synchronized HierarchyBoundsListener[] getHierarchyBoundsListeners() {
  1984.       return (HierarchyBoundsListener[])this.getListeners(HierarchyBoundsListener.class);
  1985.    }
  1986.  
  1987.    void adjustListeningChildrenOnParent(long var1, int var3) {
  1988.       if (this.parent != null) {
  1989.          this.parent.adjustListeningChildren(var1, var3);
  1990.       }
  1991.  
  1992.    }
  1993.  
  1994.    public synchronized void addKeyListener(KeyListener var1) {
  1995.       if (var1 != null) {
  1996.          this.keyListener = AWTEventMulticaster.add(this.keyListener, var1);
  1997.          this.newEventsOnly = true;
  1998.          if (this.peer instanceof LightweightPeer) {
  1999.             this.parent.proxyEnableEvents(8L);
  2000.          }
  2001.  
  2002.       }
  2003.    }
  2004.  
  2005.    public synchronized void removeKeyListener(KeyListener var1) {
  2006.       if (var1 != null) {
  2007.          this.keyListener = AWTEventMulticaster.remove(this.keyListener, var1);
  2008.       }
  2009.    }
  2010.  
  2011.    public synchronized KeyListener[] getKeyListeners() {
  2012.       return (KeyListener[])this.getListeners(KeyListener.class);
  2013.    }
  2014.  
  2015.    public synchronized void addMouseListener(MouseListener var1) {
  2016.       if (var1 != null) {
  2017.          this.mouseListener = AWTEventMulticaster.add(this.mouseListener, var1);
  2018.          this.newEventsOnly = true;
  2019.          if (this.peer instanceof LightweightPeer) {
  2020.             this.parent.proxyEnableEvents(16L);
  2021.          }
  2022.  
  2023.       }
  2024.    }
  2025.  
  2026.    public synchronized void removeMouseListener(MouseListener var1) {
  2027.       if (var1 != null) {
  2028.          this.mouseListener = AWTEventMulticaster.remove(this.mouseListener, var1);
  2029.       }
  2030.    }
  2031.  
  2032.    public synchronized MouseListener[] getMouseListeners() {
  2033.       return (MouseListener[])this.getListeners(MouseListener.class);
  2034.    }
  2035.  
  2036.    public synchronized void addMouseMotionListener(MouseMotionListener var1) {
  2037.       if (var1 != null) {
  2038.          this.mouseMotionListener = AWTEventMulticaster.add(this.mouseMotionListener, var1);
  2039.          this.newEventsOnly = true;
  2040.          if (this.peer instanceof LightweightPeer) {
  2041.             this.parent.proxyEnableEvents(32L);
  2042.          }
  2043.  
  2044.       }
  2045.    }
  2046.  
  2047.    public synchronized void removeMouseMotionListener(MouseMotionListener var1) {
  2048.       if (var1 != null) {
  2049.          this.mouseMotionListener = AWTEventMulticaster.remove(this.mouseMotionListener, var1);
  2050.       }
  2051.    }
  2052.  
  2053.    public synchronized MouseMotionListener[] getMouseMotionListeners() {
  2054.       return (MouseMotionListener[])this.getListeners(MouseMotionListener.class);
  2055.    }
  2056.  
  2057.    public synchronized void addMouseWheelListener(MouseWheelListener var1) {
  2058.       if (var1 != null) {
  2059.          this.mouseWheelListener = AWTEventMulticaster.add(this.mouseWheelListener, var1);
  2060.          this.newEventsOnly = true;
  2061.          dbg.println("Component.addMouseWheelListener(): newEventsOnly = " + this.newEventsOnly);
  2062.          if (this.peer instanceof LightweightPeer) {
  2063.             this.parent.proxyEnableEvents(131072L);
  2064.          }
  2065.  
  2066.       }
  2067.    }
  2068.  
  2069.    public synchronized void removeMouseWheelListener(MouseWheelListener var1) {
  2070.       if (var1 != null) {
  2071.          this.mouseWheelListener = AWTEventMulticaster.remove(this.mouseWheelListener, var1);
  2072.       }
  2073.    }
  2074.  
  2075.    public synchronized MouseWheelListener[] getMouseWheelListeners() {
  2076.       return (MouseWheelListener[])this.getListeners(MouseWheelListener.class);
  2077.    }
  2078.  
  2079.    public synchronized void addInputMethodListener(InputMethodListener var1) {
  2080.       if (var1 != null) {
  2081.          this.inputMethodListener = AWTEventMulticaster.add(this.inputMethodListener, var1);
  2082.          this.newEventsOnly = true;
  2083.       }
  2084.    }
  2085.  
  2086.    public synchronized void removeInputMethodListener(InputMethodListener var1) {
  2087.       if (var1 != null) {
  2088.          this.inputMethodListener = AWTEventMulticaster.remove(this.inputMethodListener, var1);
  2089.       }
  2090.    }
  2091.  
  2092.    public synchronized InputMethodListener[] getInputMethodListeners() {
  2093.       return (InputMethodListener[])this.getListeners(InputMethodListener.class);
  2094.    }
  2095.  
  2096.    public <T extends EventListener> T[] getListeners(Class<T> var1) {
  2097.       Object var2 = null;
  2098.       if (var1 == ComponentListener.class) {
  2099.          var2 = this.componentListener;
  2100.       } else if (var1 == FocusListener.class) {
  2101.          var2 = this.focusListener;
  2102.       } else if (var1 == HierarchyListener.class) {
  2103.          var2 = this.hierarchyListener;
  2104.       } else if (var1 == HierarchyBoundsListener.class) {
  2105.          var2 = this.hierarchyBoundsListener;
  2106.       } else if (var1 == KeyListener.class) {
  2107.          var2 = this.keyListener;
  2108.       } else if (var1 == MouseListener.class) {
  2109.          var2 = this.mouseListener;
  2110.       } else if (var1 == MouseMotionListener.class) {
  2111.          var2 = this.mouseMotionListener;
  2112.       } else if (var1 == MouseWheelListener.class) {
  2113.          var2 = this.mouseWheelListener;
  2114.       } else if (var1 == InputMethodListener.class) {
  2115.          var2 = this.inputMethodListener;
  2116.       } else if (var1 == PropertyChangeListener.class) {
  2117.          return (T[])(this.getPropertyChangeListeners());
  2118.       }
  2119.  
  2120.       return (T[])AWTEventMulticaster.getListeners((EventListener)var2, var1);
  2121.    }
  2122.  
  2123.    public InputMethodRequests getInputMethodRequests() {
  2124.       return null;
  2125.    }
  2126.  
  2127.    public InputContext getInputContext() {
  2128.       Container var1 = this.parent;
  2129.       return var1 == null ? null : var1.getInputContext();
  2130.    }
  2131.  
  2132.    protected final void enableEvents(long var1) {
  2133.       long var3 = 0L;
  2134.       synchronized(this) {
  2135.          if ((var1 & 32768L) != 0L && this.hierarchyListener == null && (this.eventMask & 32768L) == 0L) {
  2136.             var3 |= 32768L;
  2137.          }
  2138.  
  2139.          if ((var1 & 65536L) != 0L && this.hierarchyBoundsListener == null && (this.eventMask & 65536L) == 0L) {
  2140.             var3 |= 65536L;
  2141.          }
  2142.  
  2143.          this.eventMask |= var1;
  2144.          this.newEventsOnly = true;
  2145.       }
  2146.  
  2147.       if (this.peer instanceof LightweightPeer) {
  2148.          this.parent.proxyEnableEvents(this.eventMask);
  2149.       }
  2150.  
  2151.       if (var3 != 0L) {
  2152.          synchronized(this.getTreeLock()) {
  2153.             this.adjustListeningChildrenOnParent(var3, 1);
  2154.          }
  2155.       }
  2156.  
  2157.    }
  2158.  
  2159.    protected final void disableEvents(long var1) {
  2160.       long var3 = 0L;
  2161.       synchronized(this) {
  2162.          if ((var1 & 32768L) != 0L && this.hierarchyListener == null && (this.eventMask & 32768L) != 0L) {
  2163.             var3 |= 32768L;
  2164.          }
  2165.  
  2166.          if ((var1 & 65536L) != 0L && this.hierarchyBoundsListener == null && (this.eventMask & 65536L) != 0L) {
  2167.             var3 |= 65536L;
  2168.          }
  2169.  
  2170.          this.eventMask &= ~var1;
  2171.       }
  2172.  
  2173.       if (var3 != 0L) {
  2174.          synchronized(this.getTreeLock()) {
  2175.             this.adjustListeningChildrenOnParent(var3, -1);
  2176.          }
  2177.       }
  2178.  
  2179.    }
  2180.  
  2181.    private boolean checkCoalescing() {
  2182.       if (this.getClass().getClassLoader() == null) {
  2183.          return false;
  2184.       } else {
  2185.          Class var1 = this.getClass();
  2186.          synchronized(coalesceMap) {
  2187.             Boolean var3 = (Boolean)coalesceMap.get(var1);
  2188.             if (var3 != null) {
  2189.                return var3;
  2190.             } else {
  2191.                Boolean var4 = (Boolean)AccessController.doPrivileged(new 2(this, var1));
  2192.                coalesceMap.put(var1, var4);
  2193.                return var4;
  2194.             }
  2195.          }
  2196.       }
  2197.    }
  2198.  
  2199.    private static boolean isCoalesceEventsOverriden(Class<?> var0) {
  2200.       assert Thread.holdsLock(coalesceMap);
  2201.  
  2202.       Class var1 = var0.getSuperclass();
  2203.       if (var1 == null) {
  2204.          return false;
  2205.       } else {
  2206.          if (var1.getClassLoader() != null) {
  2207.             Boolean var2 = (Boolean)coalesceMap.get(var1);
  2208.             if (var2 == null) {
  2209.                if (isCoalesceEventsOverriden(var1)) {
  2210.                   coalesceMap.put(var1, true);
  2211.                   return true;
  2212.                }
  2213.             } else if (var2) {
  2214.                return true;
  2215.             }
  2216.          }
  2217.  
  2218.          try {
  2219.             var0.getDeclaredMethod("coalesceEvents", coalesceEventsParams);
  2220.             return true;
  2221.          } catch (NoSuchMethodException var3) {
  2222.             return false;
  2223.          }
  2224.       }
  2225.    }
  2226.  
  2227.    final boolean isCoalescingEnabled() {
  2228.       return this.coalescingEnabled;
  2229.    }
  2230.  
  2231.    protected AWTEvent coalesceEvents(AWTEvent var1, AWTEvent var2) {
  2232.       return null;
  2233.    }
  2234.  
  2235.    protected void processEvent(AWTEvent var1) {
  2236.       if (var1 instanceof FocusEvent) {
  2237.          this.processFocusEvent((FocusEvent)var1);
  2238.       } else if (var1 instanceof MouseEvent) {
  2239.          switch (var1.getID()) {
  2240.             case 500:
  2241.             case 501:
  2242.             case 502:
  2243.             case 504:
  2244.             case 505:
  2245.                this.processMouseEvent((MouseEvent)var1);
  2246.                break;
  2247.             case 503:
  2248.             case 506:
  2249.                this.processMouseMotionEvent((MouseEvent)var1);
  2250.                break;
  2251.             case 507:
  2252.                this.processMouseWheelEvent((MouseWheelEvent)var1);
  2253.          }
  2254.       } else if (var1 instanceof KeyEvent) {
  2255.          this.processKeyEvent((KeyEvent)var1);
  2256.       } else if (var1 instanceof ComponentEvent) {
  2257.          this.processComponentEvent((ComponentEvent)var1);
  2258.       } else if (var1 instanceof InputMethodEvent) {
  2259.          this.processInputMethodEvent((InputMethodEvent)var1);
  2260.       } else if (var1 instanceof HierarchyEvent) {
  2261.          switch (var1.getID()) {
  2262.             case 1400:
  2263.                this.processHierarchyEvent((HierarchyEvent)var1);
  2264.                break;
  2265.             case 1401:
  2266.             case 1402:
  2267.                this.processHierarchyBoundsEvent((HierarchyEvent)var1);
  2268.          }
  2269.       }
  2270.  
  2271.    }
  2272.  
  2273.    protected void processComponentEvent(ComponentEvent var1) {
  2274.       ComponentListener var2 = this.componentListener;
  2275.       if (var2 != null) {
  2276.          int var3 = var1.getID();
  2277.          switch (var3) {
  2278.             case 100:
  2279.                var2.componentMoved(var1);
  2280.                break;
  2281.             case 101:
  2282.                var2.componentResized(var1);
  2283.                break;
  2284.             case 102:
  2285.                var2.componentShown(var1);
  2286.                break;
  2287.             case 103:
  2288.                var2.componentHidden(var1);
  2289.          }
  2290.       }
  2291.  
  2292.    }
  2293.  
  2294.    protected void processFocusEvent(FocusEvent var1) {
  2295.       FocusListener var2 = this.focusListener;
  2296.       if (var2 != null) {
  2297.          int var3 = var1.getID();
  2298.          switch (var3) {
  2299.             case 1004:
  2300.                var2.focusGained(var1);
  2301.                break;
  2302.             case 1005:
  2303.                var2.focusLost(var1);
  2304.          }
  2305.       }
  2306.  
  2307.    }
  2308.  
  2309.    protected void processKeyEvent(KeyEvent var1) {
  2310.       KeyListener var2 = this.keyListener;
  2311.       if (var2 != null) {
  2312.          int var3 = var1.getID();
  2313.          switch (var3) {
  2314.             case 400:
  2315.                var2.keyTyped(var1);
  2316.                break;
  2317.             case 401:
  2318.                var2.keyPressed(var1);
  2319.                break;
  2320.             case 402:
  2321.                var2.keyReleased(var1);
  2322.          }
  2323.       }
  2324.  
  2325.    }
  2326.  
  2327.    protected void processMouseEvent(MouseEvent var1) {
  2328.       MouseListener var2 = this.mouseListener;
  2329.       if (var2 != null) {
  2330.          int var3 = var1.getID();
  2331.          switch (var3) {
  2332.             case 500:
  2333.                var2.mouseClicked(var1);
  2334.                break;
  2335.             case 501:
  2336.                var2.mousePressed(var1);
  2337.                break;
  2338.             case 502:
  2339.                var2.mouseReleased(var1);
  2340.             case 503:
  2341.             default:
  2342.                break;
  2343.             case 504:
  2344.                var2.mouseEntered(var1);
  2345.                break;
  2346.             case 505:
  2347.                var2.mouseExited(var1);
  2348.          }
  2349.       }
  2350.  
  2351.    }
  2352.  
  2353.    protected void processMouseMotionEvent(MouseEvent var1) {
  2354.       MouseMotionListener var2 = this.mouseMotionListener;
  2355.       if (var2 != null) {
  2356.          int var3 = var1.getID();
  2357.          switch (var3) {
  2358.             case 503:
  2359.                var2.mouseMoved(var1);
  2360.                break;
  2361.             case 506:
  2362.                var2.mouseDragged(var1);
  2363.          }
  2364.       }
  2365.  
  2366.    }
  2367.  
  2368.    protected void processMouseWheelEvent(MouseWheelEvent var1) {
  2369.       MouseWheelListener var2 = this.mouseWheelListener;
  2370.       if (var2 != null) {
  2371.          int var3 = var1.getID();
  2372.          switch (var3) {
  2373.             case 507:
  2374.                var2.mouseWheelMoved(var1);
  2375.          }
  2376.       }
  2377.  
  2378.    }
  2379.  
  2380.    boolean postsOldMouseEvents() {
  2381.       return false;
  2382.    }
  2383.  
  2384.    protected void processInputMethodEvent(InputMethodEvent var1) {
  2385.       InputMethodListener var2 = this.inputMethodListener;
  2386.       if (var2 != null) {
  2387.          int var3 = var1.getID();
  2388.          switch (var3) {
  2389.             case 1100:
  2390.                var2.inputMethodTextChanged(var1);
  2391.                break;
  2392.             case 1101:
  2393.                var2.caretPositionChanged(var1);
  2394.          }
  2395.       }
  2396.  
  2397.    }
  2398.  
  2399.    protected void processHierarchyEvent(HierarchyEvent var1) {
  2400.       HierarchyListener var2 = this.hierarchyListener;
  2401.       if (var2 != null) {
  2402.          int var3 = var1.getID();
  2403.          switch (var3) {
  2404.             case 1400:
  2405.                var2.hierarchyChanged(var1);
  2406.          }
  2407.       }
  2408.  
  2409.    }
  2410.  
  2411.    protected void processHierarchyBoundsEvent(HierarchyEvent var1) {
  2412.       HierarchyBoundsListener var2 = this.hierarchyBoundsListener;
  2413.       if (var2 != null) {
  2414.          int var3 = var1.getID();
  2415.          switch (var3) {
  2416.             case 1401:
  2417.                var2.ancestorMoved(var1);
  2418.                break;
  2419.             case 1402:
  2420.                var2.ancestorResized(var1);
  2421.          }
  2422.       }
  2423.  
  2424.    }
  2425.  
  2426.    /** @deprecated */
  2427.    @Deprecated
  2428.    public boolean handleEvent(Event var1) {
  2429.       switch (var1.id) {
  2430.          case 401:
  2431.          case 403:
  2432.             return this.keyDown(var1, var1.key);
  2433.          case 402:
  2434.          case 404:
  2435.             return this.keyUp(var1, var1.key);
  2436.          case 501:
  2437.             return this.mouseDown(var1, var1.x, var1.y);
  2438.          case 502:
  2439.             return this.mouseUp(var1, var1.x, var1.y);
  2440.          case 503:
  2441.             return this.mouseMove(var1, var1.x, var1.y);
  2442.          case 504:
  2443.             return this.mouseEnter(var1, var1.x, var1.y);
  2444.          case 505:
  2445.             return this.mouseExit(var1, var1.x, var1.y);
  2446.          case 506:
  2447.             return this.mouseDrag(var1, var1.x, var1.y);
  2448.          case 1001:
  2449.             return this.action(var1, var1.arg);
  2450.          case 1004:
  2451.             return this.gotFocus(var1, var1.arg);
  2452.          case 1005:
  2453.             return this.lostFocus(var1, var1.arg);
  2454.          default:
  2455.             return false;
  2456.       }
  2457.    }
  2458.  
  2459.    /** @deprecated */
  2460.    @Deprecated
  2461.    public boolean mouseDown(Event var1, int var2, int var3) {
  2462.       return false;
  2463.    }
  2464.  
  2465.    /** @deprecated */
  2466.    @Deprecated
  2467.    public boolean mouseDrag(Event var1, int var2, int var3) {
  2468.       return false;
  2469.    }
  2470.  
  2471.    /** @deprecated */
  2472.    @Deprecated
  2473.    public boolean mouseUp(Event var1, int var2, int var3) {
  2474.       return false;
  2475.    }
  2476.  
  2477.    /** @deprecated */
  2478.    @Deprecated
  2479.    public boolean mouseMove(Event var1, int var2, int var3) {
  2480.       return false;
  2481.    }
  2482.  
  2483.    /** @deprecated */
  2484.    @Deprecated
  2485.    public boolean mouseEnter(Event var1, int var2, int var3) {
  2486.       return false;
  2487.    }
  2488.  
  2489.    /** @deprecated */
  2490.    @Deprecated
  2491.    public boolean mouseExit(Event var1, int var2, int var3) {
  2492.       return false;
  2493.    }
  2494.  
  2495.    /** @deprecated */
  2496.    @Deprecated
  2497.    public boolean keyDown(Event var1, int var2) {
  2498.       return false;
  2499.    }
  2500.  
  2501.    /** @deprecated */
  2502.    @Deprecated
  2503.    public boolean keyUp(Event var1, int var2) {
  2504.       return false;
  2505.    }
  2506.  
  2507.    /** @deprecated */
  2508.    @Deprecated
  2509.    public boolean action(Event var1, Object var2) {
  2510.       return false;
  2511.    }
  2512.  
  2513.    public void addNotify() {
  2514.       synchronized(this.getTreeLock()) {
  2515.          Object var2 = this.peer;
  2516.          if (var2 != null && !(var2 instanceof LightweightPeer)) {
  2517.             Container var8 = this.parent;
  2518.             if (var8 != null && var8.peer instanceof LightweightPeer) {
  2519.                this.nativeInLightFixer = new NativeInLightFixer(this);
  2520.             }
  2521.          } else {
  2522.             if (var2 == null) {
  2523.                this.peer = (ComponentPeer)(var2 = this.getToolkit().createComponent(this));
  2524.             }
  2525.  
  2526.             if (this.parent != null) {
  2527.                long var3 = 0L;
  2528.                if (this.mouseListener != null || (this.eventMask & 16L) != 0L) {
  2529.                   var3 |= 16L;
  2530.                }
  2531.  
  2532.                if (this.mouseMotionListener != null || (this.eventMask & 32L) != 0L) {
  2533.                   var3 |= 32L;
  2534.                }
  2535.  
  2536.                if (this.mouseWheelListener != null || (this.eventMask & 131072L) != 0L) {
  2537.                   var3 |= 131072L;
  2538.                }
  2539.  
  2540.                if (this.focusListener != null || (this.eventMask & 4L) != 0L) {
  2541.                   var3 |= 4L;
  2542.                }
  2543.  
  2544.                if (this.keyListener != null || (this.eventMask & 8L) != 0L) {
  2545.                   var3 |= 8L;
  2546.                }
  2547.  
  2548.                if (var3 != 0L) {
  2549.                   this.parent.proxyEnableEvents(var3);
  2550.                }
  2551.             }
  2552.          }
  2553.  
  2554.          this.invalidate();
  2555.          int var9 = this.popups != null ? this.popups.size() : 0;
  2556.  
  2557.          for(int var4 = 0; var4 < var9; ++var4) {
  2558.             PopupMenu var5 = (PopupMenu)this.popups.elementAt(var4);
  2559.             var5.addNotify();
  2560.          }
  2561.  
  2562.          if (this.dropTarget != null) {
  2563.             this.dropTarget.addNotify((ComponentPeer)var2);
  2564.          }
  2565.  
  2566.          this.peerFont = this.getFont();
  2567.          if (this.parent != null && this.parent.peer != null) {
  2568.             ContainerPeer var10 = (ContainerPeer)this.parent.peer;
  2569.             if (var10 instanceof LightweightPeer && !(var2 instanceof LightweightPeer)) {
  2570.                Container var12 = this.getNativeContainer();
  2571.                if (var12 != null && var12.peer != null) {
  2572.                   var10 = (ContainerPeer)var12.peer;
  2573.                }
  2574.             }
  2575.  
  2576.             if (var10.isRestackSupported()) {
  2577.                var10.restack();
  2578.             }
  2579.          }
  2580.  
  2581.          if (this.hierarchyListener != null || (this.eventMask & 32768L) != 0L || Toolkit.enabledOnToolkit(32768L)) {
  2582.             HierarchyEvent var11 = new HierarchyEvent(this, 1400, this, this.parent, (long)(2 | (this.isRecursivelyVisible() ? 4 : 0)));
  2583.             this.dispatchEvent(var11);
  2584.          }
  2585.  
  2586.       }
  2587.    }
  2588.  
  2589.    public void removeNotify() {
  2590.       KeyboardFocusManager.clearMostRecentFocusOwner(this);
  2591.       if (KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner() == this) {
  2592.          KeyboardFocusManager.getCurrentKeyboardFocusManager().setGlobalPermanentFocusOwner((Component)null);
  2593.       }
  2594.  
  2595.       synchronized(this.getTreeLock()) {
  2596.          if (this.isFocusOwner() && !this.nextFocusHelper()) {
  2597.             KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
  2598.          }
  2599.  
  2600.          int var2 = this.popups != null ? this.popups.size() : 0;
  2601.  
  2602.          for(int var3 = 0; var3 < var2; ++var3) {
  2603.             PopupMenu var4 = (PopupMenu)this.popups.elementAt(var3);
  2604.             var4.removeNotify();
  2605.          }
  2606.  
  2607.          if ((this.eventMask & 4096L) != 0L) {
  2608.             InputContext var7 = this.getInputContext();
  2609.             if (var7 != null) {
  2610.                var7.removeNotify(this);
  2611.             }
  2612.          }
  2613.  
  2614.          if (this.nativeInLightFixer != null) {
  2615.             this.nativeInLightFixer.uninstall();
  2616.          }
  2617.  
  2618.          ComponentPeer var8 = this.peer;
  2619.          if (var8 != null) {
  2620.             if (this.bufferStrategy instanceof FlipBufferStrategy) {
  2621.                ((FlipBufferStrategy)this.bufferStrategy).destroyBuffers();
  2622.             }
  2623.  
  2624.             if (this.dropTarget != null) {
  2625.                this.dropTarget.removeNotify(this.peer);
  2626.             }
  2627.  
  2628.             if (this.visible) {
  2629.                var8.hide();
  2630.             }
  2631.  
  2632.             this.peer = null;
  2633.             this.peerFont = null;
  2634.             Toolkit.getEventQueue().removeSourceEvents(this, false);
  2635.             KeyboardFocusManager.getCurrentKeyboardFocusManager().discardKeyEvents(this);
  2636.             var8.dispose();
  2637.          }
  2638.  
  2639.          if (this.hierarchyListener != null || (this.eventMask & 32768L) != 0L || Toolkit.enabledOnToolkit(32768L)) {
  2640.             HierarchyEvent var9 = new HierarchyEvent(this, 1400, this, this.parent, (long)(2 | (this.isRecursivelyVisible() ? 4 : 0)));
  2641.             this.dispatchEvent(var9);
  2642.          }
  2643.  
  2644.       }
  2645.    }
  2646.  
  2647.    /** @deprecated */
  2648.    @Deprecated
  2649.    public boolean gotFocus(Event var1, Object var2) {
  2650.       return false;
  2651.    }
  2652.  
  2653.    /** @deprecated */
  2654.    @Deprecated
  2655.    public boolean lostFocus(Event var1, Object var2) {
  2656.       return false;
  2657.    }
  2658.  
  2659.    /** @deprecated */
  2660.    @Deprecated
  2661.    public boolean isFocusTraversable() {
  2662.       if (this.isFocusTraversableOverridden == 0) {
  2663.          this.isFocusTraversableOverridden = 1;
  2664.       }
  2665.  
  2666.       return this.focusable;
  2667.    }
  2668.  
  2669.    public boolean isFocusable() {
  2670.       return this.isFocusTraversable();
  2671.    }
  2672.  
  2673.    public void setFocusable(boolean var1) {
  2674.       boolean var2;
  2675.       synchronized(this) {
  2676.          var2 = this.focusable;
  2677.          this.focusable = var1;
  2678.       }
  2679.  
  2680.       this.isFocusTraversableOverridden = 2;
  2681.       this.firePropertyChange("focusable", var2, var1);
  2682.       if (var2 && !var1) {
  2683.          if (this.isFocusOwner()) {
  2684.             this.autoTransferFocus(true);
  2685.          }
  2686.  
  2687.          KeyboardFocusManager.clearMostRecentFocusOwner(this);
  2688.       }
  2689.  
  2690.    }
  2691.  
  2692.    final boolean isFocusTraversableOverridden() {
  2693.       return this.isFocusTraversableOverridden != 1;
  2694.    }
  2695.  
  2696.    public void setFocusTraversalKeys(int var1, Set<? extends AWTKeyStroke> var2) {
  2697.       if (var1 >= 0 && var1 < 3) {
  2698.          this.setFocusTraversalKeys_NoIDCheck(var1, var2);
  2699.       } else {
  2700.          throw new IllegalArgumentException("invalid focus traversal key identifier");
  2701.       }
  2702.    }
  2703.  
  2704.    public Set<AWTKeyStroke> getFocusTraversalKeys(int var1) {
  2705.       if (var1 >= 0 && var1 < 3) {
  2706.          return this.getFocusTraversalKeys_NoIDCheck(var1);
  2707.       } else {
  2708.          throw new IllegalArgumentException("invalid focus traversal key identifier");
  2709.       }
  2710.    }
  2711.  
  2712.    final void setFocusTraversalKeys_NoIDCheck(int var1, Set<? extends AWTKeyStroke> var2) {
  2713.       Set var3;
  2714.       synchronized(this) {
  2715.          if (this.focusTraversalKeys == null) {
  2716.             this.initializeFocusTraversalKeys();
  2717.          }
  2718.  
  2719.          if (var2 != null) {
  2720.             for(Object var6 : var2) {
  2721.                if (var6 == null) {
  2722.                   throw new IllegalArgumentException("cannot set null focus traversal key");
  2723.                }
  2724.  
  2725.                if (!(var6 instanceof AWTKeyStroke)) {
  2726.                   throw new IllegalArgumentException("object is expected to be AWTKeyStroke");
  2727.                }
  2728.  
  2729.                AWTKeyStroke var7 = (AWTKeyStroke)var6;
  2730.                if (var7.getKeyChar() != '\uffff') {
  2731.                   throw new IllegalArgumentException("focus traversal keys cannot map to KEY_TYPED events");
  2732.                }
  2733.  
  2734.                for(int var8 = 0; var8 < this.focusTraversalKeys.length; ++var8) {
  2735.                   if (var8 != var1 && this.getFocusTraversalKeys_NoIDCheck(var8).contains(var7)) {
  2736.                      throw new IllegalArgumentException("focus traversal keys must be unique for a Component");
  2737.                   }
  2738.                }
  2739.             }
  2740.          }
  2741.  
  2742.          var3 = this.focusTraversalKeys[var1];
  2743.          this.focusTraversalKeys[var1] = var2 != null ? Collections.unmodifiableSet(new HashSet(var2)) : null;
  2744.       }
  2745.  
  2746.       this.firePropertyChange(focusTraversalKeyPropertyNames[var1], var3, var2);
  2747.    }
  2748.  
  2749.    final Set getFocusTraversalKeys_NoIDCheck(int var1) {
  2750.       Set var2 = this.focusTraversalKeys != null ? this.focusTraversalKeys[var1] : null;
  2751.       if (var2 != null) {
  2752.          return var2;
  2753.       } else {
  2754.          Container var3 = this.parent;
  2755.          return var3 != null ? var3.getFocusTraversalKeys(var1) : KeyboardFocusManager.getCurrentKeyboardFocusManager().getDefaultFocusTraversalKeys(var1);
  2756.       }
  2757.    }
  2758.  
  2759.    public boolean areFocusTraversalKeysSet(int var1) {
  2760.       if (var1 >= 0 && var1 < 3) {
  2761.          return this.focusTraversalKeys != null && this.focusTraversalKeys[var1] != null;
  2762.       } else {
  2763.          throw new IllegalArgumentException("invalid focus traversal key identifier");
  2764.       }
  2765.    }
  2766.  
  2767.    public void setFocusTraversalKeysEnabled(boolean var1) {
  2768.       boolean var2;
  2769.       synchronized(this) {
  2770.          var2 = this.focusTraversalKeysEnabled;
  2771.          this.focusTraversalKeysEnabled = var1;
  2772.       }
  2773.  
  2774.       this.firePropertyChange("focusTraversalKeysEnabled", var2, var1);
  2775.    }
  2776.  
  2777.    public boolean getFocusTraversalKeysEnabled() {
  2778.       return this.focusTraversalKeysEnabled;
  2779.    }
  2780.  
  2781.    public void requestFocus() {
  2782.       this.requestFocusHelper(false, true);
  2783.    }
  2784.  
  2785.    void requestFocus(CausedFocusEvent.Cause var1) {
  2786.       this.requestFocusHelper(false, true, var1);
  2787.    }
  2788.  
  2789.    protected boolean requestFocus(boolean var1) {
  2790.       return this.requestFocusHelper(var1, true);
  2791.    }
  2792.  
  2793.    boolean requestFocus(boolean var1, CausedFocusEvent.Cause var2) {
  2794.       return this.requestFocusHelper(var1, true, var2);
  2795.    }
  2796.  
  2797.    public boolean requestFocusInWindow() {
  2798.       return this.requestFocusHelper(false, false);
  2799.    }
  2800.  
  2801.    boolean requestFocusInWindow(CausedFocusEvent.Cause var1) {
  2802.       return this.requestFocusHelper(false, false, var1);
  2803.    }
  2804.  
  2805.    protected boolean requestFocusInWindow(boolean var1) {
  2806.       return this.requestFocusHelper(var1, false);
  2807.    }
  2808.  
  2809.    boolean requestFocusInWindow(boolean var1, CausedFocusEvent.Cause var2) {
  2810.       return this.requestFocusHelper(var1, false, var2);
  2811.    }
  2812.  
  2813.    final boolean requestFocusHelper(boolean var1, boolean var2) {
  2814.       return this.requestFocusHelper(var1, var2, Cause.UNKNOWN);
  2815.    }
  2816.  
  2817.    final boolean requestFocusHelper(boolean var1, boolean var2, CausedFocusEvent.Cause var3) {
  2818.       if (!this.isRequestFocusAccepted(var1, var2, var3)) {
  2819.          focusLog.finest("requestFocus is not accepted");
  2820.          return false;
  2821.       } else {
  2822.          KeyboardFocusManager.setMostRecentFocusOwner(this);
  2823.  
  2824.          for(Object var4 = this; var4 != null && !(var4 instanceof Window); var4 = ((Component)var4).parent) {
  2825.             if (!((Component)var4).isVisible()) {
  2826.                focusLog.finest("component is recurively invisible");
  2827.                return false;
  2828.             }
  2829.          }
  2830.  
  2831.          ComponentPeer var5 = this.peer;
  2832.          Object var6 = var5 instanceof LightweightPeer ? this.getNativeContainer() : this;
  2833.          if (var6 != null && ((Component)var6).isVisible()) {
  2834.             var5 = ((Component)var6).peer;
  2835.             if (var5 == null) {
  2836.                focusLog.finest("Peer is null");
  2837.                return false;
  2838.             } else {
  2839.                long var7 = EventQueue.getMostRecentEventTime();
  2840.                boolean var9 = var5.requestFocus(this, var1, var2, var7, var3);
  2841.                if (!var9) {
  2842.                   KeyboardFocusManager.getCurrentKeyboardFocusManager(this.appContext).dequeueKeyEvents(var7, this);
  2843.                   focusLog.finest("Peer request failed");
  2844.                } else if (focusLog.isLoggable(Level.FINEST)) {
  2845.                   focusLog.finest("Pass for " + this);
  2846.                }
  2847.  
  2848.                return var9;
  2849.             }
  2850.          } else {
  2851.             focusLog.finest("Component is not a part of visible hierarchy");
  2852.             return false;
  2853.          }
  2854.       }
  2855.    }
  2856.  
  2857.    private boolean isRequestFocusAccepted(boolean var1, boolean var2, CausedFocusEvent.Cause var3) {
  2858.       if (this.isFocusable() && this.isVisible()) {
  2859.          ComponentPeer var4 = this.peer;
  2860.          if (var4 == null) {
  2861.             focusLog.finest("peer is null");
  2862.             return false;
  2863.          } else {
  2864.             Window var5 = this.getContainingWindow();
  2865.             if (var5 != null && var5.isFocusableWindow()) {
  2866.                Component var6 = KeyboardFocusManager.getMostRecentFocusOwner(var5);
  2867.                if (var6 == null) {
  2868.                   var6 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
  2869.                   if (var6 != null && getContainingWindow(var6) != var5) {
  2870.                      var6 = null;
  2871.                   }
  2872.                }
  2873.  
  2874.                if (var6 != this && var6 != null) {
  2875.                   if (Cause.ACTIVATION == var3) {
  2876.                      focusLog.finest("cause is activation");
  2877.                      return true;
  2878.                   } else {
  2879.                      boolean var7 = requestFocusController.acceptRequestFocus(var6, this, var1, var2, var3);
  2880.                      if (focusLog.isLoggable(Level.FINEST)) {
  2881.                         focusLog.log(Level.FINEST, "RequestFocusController returns {0}", var7);
  2882.                      }
  2883.  
  2884.                      return var7;
  2885.                   }
  2886.                } else {
  2887.                   focusLog.finest("focus owner is null or this");
  2888.                   return true;
  2889.                }
  2890.             } else {
  2891.                focusLog.finest("Component doesn't have toplevel");
  2892.                return false;
  2893.             }
  2894.          }
  2895.       } else {
  2896.          focusLog.finest("Not focusable or not visible");
  2897.          return false;
  2898.       }
  2899.    }
  2900.  
  2901.    static synchronized void setRequestFocusController(RequestFocusController var0) {
  2902.       if (var0 == null) {
  2903.          requestFocusController = new DummyRequestFocusController((1)null);
  2904.       } else {
  2905.          requestFocusController = var0;
  2906.       }
  2907.  
  2908.    }
  2909.  
  2910.    final void autoTransferFocus(boolean var1) {
  2911.       Component var2 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
  2912.       if (var2 != this) {
  2913.          if (var2 != null) {
  2914.             var2.autoTransferFocus(var1);
  2915.          }
  2916.  
  2917.       } else if (!KeyboardFocusManager.hasFocusRequests()) {
  2918.          if (this.isDisplayable() && this.isVisible() && this.isEnabled() && this.isFocusable()) {
  2919.             var2 = this.getParent();
  2920.  
  2921.             while(true) {
  2922.                if (var2 != null && !(var2 instanceof Window)) {
  2923.                   if (var2.isDisplayable() && var2.isVisible() && (var2.isEnabled() || var2.isLightweight())) {
  2924.                      var2 = var2.getParent();
  2925.                      continue;
  2926.                   }
  2927.  
  2928.                   this.doAutoTransfer(var1);
  2929.                   return;
  2930.                }
  2931.  
  2932.                return;
  2933.             }
  2934.          } else {
  2935.             this.doAutoTransfer(var1);
  2936.          }
  2937.       }
  2938.    }
  2939.  
  2940.    private void doAutoTransfer(boolean var1) {
  2941.       if (var1) {
  2942.          if (!this.nextFocusHelper()) {
  2943.             KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
  2944.          }
  2945.       } else {
  2946.          this.transferFocus();
  2947.       }
  2948.  
  2949.    }
  2950.  
  2951.    public void transferFocus() {
  2952.       this.nextFocus();
  2953.    }
  2954.  
  2955.    public Container getFocusCycleRootAncestor() {
  2956.       Container var1;
  2957.       for(var1 = this.parent; var1 != null && !var1.isFocusCycleRoot(); var1 = var1.parent) {
  2958.       }
  2959.  
  2960.       return var1;
  2961.    }
  2962.  
  2963.    public boolean isFocusCycleRoot(Container var1) {
  2964.       Container var2 = this.getFocusCycleRootAncestor();
  2965.       return var2 == var1;
  2966.    }
  2967.  
  2968.    /** @deprecated */
  2969.    @Deprecated
  2970.    public void nextFocus() {
  2971.       this.nextFocusHelper();
  2972.    }
  2973.  
  2974.    boolean nextFocusHelper() {
  2975.       Component var1 = this.preNextFocusHelper();
  2976.       return this.isFocusOwner() && var1 == this ? false : postNextFocusHelper(var1);
  2977.    }
  2978.  
  2979.    Component preNextFocusHelper() {
  2980.       Container var1 = this.getFocusCycleRootAncestor();
  2981.  
  2982.       Object var2;
  2983.       for(var2 = this; var1 != null && (!var1.isShowing() || !var1.isFocusable() || !var1.isEnabled()); var1 = ((Component)var1).getFocusCycleRootAncestor()) {
  2984.          var2 = var1;
  2985.       }
  2986.  
  2987.       if (var1 != null) {
  2988.          FocusTraversalPolicy var3 = var1.getFocusTraversalPolicy();
  2989.          Object var4 = var3.getComponentAfter(var1, (Component)var2);
  2990.          if (var4 == null) {
  2991.             var4 = var3.getDefaultComponent(var1);
  2992.          }
  2993.  
  2994.          if (var4 == null) {
  2995.             Applet var5 = EmbeddedFrame.getAppletIfAncestorOf(this);
  2996.             if (var5 != null) {
  2997.                var4 = var5;
  2998.             }
  2999.          }
  3000.  
  3001.          return (Component)var4;
  3002.       } else {
  3003.          return null;
  3004.       }
  3005.    }
  3006.  
  3007.    static boolean postNextFocusHelper(Component var0) {
  3008.       if (var0 != null) {
  3009.          if (focusLog.isLoggable(Level.FINER)) {
  3010.             focusLog.finer("Next component " + var0);
  3011.          }
  3012.  
  3013.          boolean var1 = var0.requestFocus(false, Cause.TRAVERSAL_FORWARD);
  3014.          if (focusLog.isLoggable(Level.FINER)) {
  3015.             focusLog.finer("Request focus returned " + var1);
  3016.          }
  3017.  
  3018.          return var1;
  3019.       } else {
  3020.          return false;
  3021.       }
  3022.    }
  3023.  
  3024.    public void transferFocusBackward() {
  3025.       Container var1 = this.getFocusCycleRootAncestor();
  3026.  
  3027.       Object var2;
  3028.       for(var2 = this; var1 != null && (!var1.isShowing() || !var1.isFocusable() || !var1.isEnabled()); var1 = ((Component)var1).getFocusCycleRootAncestor()) {
  3029.          var2 = var1;
  3030.       }
  3031.  
  3032.       if (var1 != null) {
  3033.          FocusTraversalPolicy var3 = var1.getFocusTraversalPolicy();
  3034.          Component var4 = var3.getComponentBefore(var1, (Component)var2);
  3035.          if (var4 == null) {
  3036.             var4 = var3.getDefaultComponent(var1);
  3037.          }
  3038.  
  3039.          if (var4 != null) {
  3040.             var4.requestFocus(Cause.TRAVERSAL_BACKWARD);
  3041.          }
  3042.       }
  3043.  
  3044.    }
  3045.  
  3046.    public void transferFocusUpCycle() {
  3047.       Container var1;
  3048.       for(var1 = this.getFocusCycleRootAncestor(); var1 != null && (!var1.isShowing() || !var1.isFocusable() || !var1.isEnabled()); var1 = var1.getFocusCycleRootAncestor()) {
  3049.       }
  3050.  
  3051.       if (var1 != null) {
  3052.          Container var2 = var1.getFocusCycleRootAncestor();
  3053.          KeyboardFocusManager.getCurrentKeyboardFocusManager().setGlobalCurrentFocusCycleRoot(var2 != null ? var2 : var1);
  3054.          var1.requestFocus(Cause.TRAVERSAL_UP);
  3055.       } else {
  3056.          Container var4;
  3057.          for(var4 = this instanceof Container ? (Container)this : this.getParent(); var4 != null && !(var4 instanceof Window); var4 = var4.getParent()) {
  3058.          }
  3059.  
  3060.          if (var4 != null) {
  3061.             Component var3 = var4.getFocusTraversalPolicy().getDefaultComponent(var4);
  3062.             if (var3 != null) {
  3063.                KeyboardFocusManager.getCurrentKeyboardFocusManager().setGlobalCurrentFocusCycleRoot(var4);
  3064.                var3.requestFocus(Cause.TRAVERSAL_UP);
  3065.             }
  3066.          }
  3067.       }
  3068.  
  3069.    }
  3070.  
  3071.    public boolean hasFocus() {
  3072.       return KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() == this;
  3073.    }
  3074.  
  3075.    public boolean isFocusOwner() {
  3076.       return this.hasFocus();
  3077.    }
  3078.  
  3079.    public synchronized void add(PopupMenu var1) {
  3080.       if (var1.parent != null) {
  3081.          var1.parent.remove(var1);
  3082.       }
  3083.  
  3084.       if (this.popups == null) {
  3085.          this.popups = new Vector();
  3086.       }
  3087.  
  3088.       this.popups.addElement(var1);
  3089.       var1.parent = this;
  3090.       if (this.peer != null && var1.peer == null) {
  3091.          var1.addNotify();
  3092.       }
  3093.  
  3094.    }
  3095.  
  3096.    public synchronized void remove(MenuComponent var1) {
  3097.       if (this.popups != null) {
  3098.          int var2 = this.popups.indexOf(var1);
  3099.          if (var2 >= 0) {
  3100.             PopupMenu var3 = (PopupMenu)var1;
  3101.             if (var3.peer != null) {
  3102.                var3.removeNotify();
  3103.             }
  3104.  
  3105.             var3.parent = null;
  3106.             this.popups.removeElementAt(var2);
  3107.             if (this.popups.size() == 0) {
  3108.                this.popups = null;
  3109.             }
  3110.          }
  3111.       }
  3112.  
  3113.    }
  3114.  
  3115.    protected String paramString() {
  3116.       String var1 = this.getName();
  3117.       String var2 = (var1 != null ? var1 : "") + "," + this.field_0 + "," + this.field_1 + "," + this.width + "x" + this.height;
  3118.       if (!this.valid) {
  3119.          var2 = var2 + ",invalid";
  3120.       }
  3121.  
  3122.       if (!this.visible) {
  3123.          var2 = var2 + ",hidden";
  3124.       }
  3125.  
  3126.       if (!this.enabled) {
  3127.          var2 = var2 + ",disabled";
  3128.       }
  3129.  
  3130.       return var2;
  3131.    }
  3132.  
  3133.    public String toString() {
  3134.       return this.getClass().getName() + "[" + this.paramString() + "]";
  3135.    }
  3136.  
  3137.    public void list() {
  3138.       this.list((PrintStream)System.out, 0);
  3139.    }
  3140.  
  3141.    public void list(PrintStream var1) {
  3142.       this.list((PrintStream)var1, 0);
  3143.    }
  3144.  
  3145.    public void list(PrintStream var1, int var2) {
  3146.       for(int var3 = 0; var3 < var2; ++var3) {
  3147.          var1.print(" ");
  3148.       }
  3149.  
  3150.       var1.println(this);
  3151.    }
  3152.  
  3153.    public void list(PrintWriter var1) {
  3154.       this.list((PrintWriter)var1, 0);
  3155.    }
  3156.  
  3157.    public void list(PrintWriter var1, int var2) {
  3158.       for(int var3 = 0; var3 < var2; ++var3) {
  3159.          var1.print(" ");
  3160.       }
  3161.  
  3162.       var1.println(this);
  3163.    }
  3164.  
  3165.    Container getNativeContainer() {
  3166.       Container var1;
  3167.       for(var1 = this.parent; var1 != null && var1.peer instanceof LightweightPeer; var1 = var1.getParent()) {
  3168.       }
  3169.  
  3170.       return var1;
  3171.    }
  3172.  
  3173.    public synchronized void addPropertyChangeListener(PropertyChangeListener var1) {
  3174.       if (var1 != null) {
  3175.          if (this.changeSupport == null) {
  3176.             this.changeSupport = new PropertyChangeSupport(this);
  3177.          }
  3178.  
  3179.          this.changeSupport.addPropertyChangeListener(var1);
  3180.       }
  3181.    }
  3182.  
  3183.    public synchronized void removePropertyChangeListener(PropertyChangeListener var1) {
  3184.       if (var1 != null && this.changeSupport != null) {
  3185.          this.changeSupport.removePropertyChangeListener(var1);
  3186.       }
  3187.    }
  3188.  
  3189.    public synchronized PropertyChangeListener[] getPropertyChangeListeners() {
  3190.       return this.changeSupport == null ? new PropertyChangeListener[0] : this.changeSupport.getPropertyChangeListeners();
  3191.    }
  3192.  
  3193.    public synchronized void addPropertyChangeListener(String var1, PropertyChangeListener var2) {
  3194.       if (var2 != null) {
  3195.          if (this.changeSupport == null) {
  3196.             this.changeSupport = new PropertyChangeSupport(this);
  3197.          }
  3198.  
  3199.          this.changeSupport.addPropertyChangeListener(var1, var2);
  3200.       }
  3201.    }
  3202.  
  3203.    public synchronized void removePropertyChangeListener(String var1, PropertyChangeListener var2) {
  3204.       if (var2 != null && this.changeSupport != null) {
  3205.          this.changeSupport.removePropertyChangeListener(var1, var2);
  3206.       }
  3207.    }
  3208.  
  3209.    public synchronized PropertyChangeListener[] getPropertyChangeListeners(String var1) {
  3210.       return this.changeSupport == null ? new PropertyChangeListener[0] : this.changeSupport.getPropertyChangeListeners(var1);
  3211.    }
  3212.  
  3213.    protected void firePropertyChange(String var1, Object var2, Object var3) {
  3214.       PropertyChangeSupport var4 = this.changeSupport;
  3215.       if (var4 != null && (var2 == null || var3 == null || !var2.equals(var3))) {
  3216.          var4.firePropertyChange(var1, var2, var3);
  3217.       }
  3218.    }
  3219.  
  3220.    protected void firePropertyChange(String var1, boolean var2, boolean var3) {
  3221.       PropertyChangeSupport var4 = this.changeSupport;
  3222.       if (var4 != null && var2 != var3) {
  3223.          var4.firePropertyChange(var1, var2, var3);
  3224.       }
  3225.    }
  3226.  
  3227.    protected void firePropertyChange(String var1, int var2, int var3) {
  3228.       PropertyChangeSupport var4 = this.changeSupport;
  3229.       if (var4 != null && var2 != var3) {
  3230.          var4.firePropertyChange(var1, var2, var3);
  3231.       }
  3232.    }
  3233.  
  3234.    public void firePropertyChange(String var1, byte var2, byte var3) {
  3235.       if (this.changeSupport != null && var2 != var3) {
  3236.          this.firePropertyChange(var1, var2, var3);
  3237.       }
  3238.    }
  3239.  
  3240.    public void firePropertyChange(String var1, char var2, char var3) {
  3241.       if (this.changeSupport != null && var2 != var3) {
  3242.          this.firePropertyChange(var1, new Character(var2), new Character(var3));
  3243.       }
  3244.    }
  3245.  
  3246.    public void firePropertyChange(String var1, short var2, short var3) {
  3247.       if (this.changeSupport != null && var2 != var3) {
  3248.          this.firePropertyChange(var1, var2, var3);
  3249.       }
  3250.    }
  3251.  
  3252.    public void firePropertyChange(String var1, long var2, long var4) {
  3253.       if (this.changeSupport != null && var2 != var4) {
  3254.          this.firePropertyChange(var1, var2, var4);
  3255.       }
  3256.    }
  3257.  
  3258.    public void firePropertyChange(String var1, float var2, float var3) {
  3259.       if (this.changeSupport != null && var2 != var3) {
  3260.          this.firePropertyChange(var1, var2, var3);
  3261.       }
  3262.    }
  3263.  
  3264.    public void firePropertyChange(String var1, double var2, double var4) {
  3265.       if (this.changeSupport != null && var2 != var4) {
  3266.          this.firePropertyChange(var1, var2, var4);
  3267.       }
  3268.    }
  3269.  
  3270.    private void doSwingSerialization() {
  3271.       Package var1 = Package.getPackage("javax.swing");
  3272.  
  3273.       for(Class var2 = this.getClass(); var2 != null; var2 = var2.getSuperclass()) {
  3274.          if (var2.getPackage() == var1 && var2.getClassLoader() == null) {
  3275.             Method[] var4 = (Method[])AccessController.doPrivileged(new 3(this, var2));
  3276.  
  3277.             for(int var5 = var4.length - 1; var5 >= 0; --var5) {
  3278.                Method var6 = var4[var5];
  3279.                if (var6.getName().equals("compWriteObjectNotify")) {
  3280.                   AccessController.doPrivileged(new 4(this, var6));
  3281.  
  3282.                   try {
  3283.                      var6.invoke(this, (Object[])null);
  3284.                   } catch (IllegalAccessException var8) {
  3285.                   } catch (InvocationTargetException var9) {
  3286.                   }
  3287.  
  3288.                   return;
  3289.                }
  3290.             }
  3291.          }
  3292.       }
  3293.  
  3294.    }
  3295.  
  3296.    private void writeObject(ObjectOutputStream var1) throws IOException {
  3297.       this.doSwingSerialization();
  3298.       var1.defaultWriteObject();
  3299.       AWTEventMulticaster.save(var1, "componentL", this.componentListener);
  3300.       AWTEventMulticaster.save(var1, "focusL", this.focusListener);
  3301.       AWTEventMulticaster.save(var1, "keyL", this.keyListener);
  3302.       AWTEventMulticaster.save(var1, "mouseL", this.mouseListener);
  3303.       AWTEventMulticaster.save(var1, "mouseMotionL", this.mouseMotionListener);
  3304.       AWTEventMulticaster.save(var1, "inputMethodL", this.inputMethodListener);
  3305.       var1.writeObject((Object)null);
  3306.       var1.writeObject(this.componentOrientation);
  3307.       AWTEventMulticaster.save(var1, "hierarchyL", this.hierarchyListener);
  3308.       AWTEventMulticaster.save(var1, "hierarchyBoundsL", this.hierarchyBoundsListener);
  3309.       var1.writeObject((Object)null);
  3310.       AWTEventMulticaster.save(var1, "mouseWheelL", this.mouseWheelListener);
  3311.       var1.writeObject((Object)null);
  3312.    }
  3313.  
  3314.    private void readObject(ObjectInputStream var1) throws ClassNotFoundException, IOException {
  3315.       var1.defaultReadObject();
  3316.       this.privateKey = new Object();
  3317.       this.appContext = AppContext.getAppContext();
  3318.       this.coalescingEnabled = this.checkCoalescing();
  3319.       if (this.componentSerializedDataVersion < 4) {
  3320.          this.focusable = true;
  3321.          this.isFocusTraversableOverridden = 0;
  3322.          this.initializeFocusTraversalKeys();
  3323.          this.focusTraversalKeysEnabled = true;
  3324.       }
  3325.  
  3326.       Object var2;
  3327.       while(null != (var2 = var1.readObject())) {
  3328.          String var3 = ((String)var2).intern();
  3329.          if ("componentL" == var3) {
  3330.             this.addComponentListener((ComponentListener)var1.readObject());
  3331.          } else if ("focusL" == var3) {
  3332.             this.addFocusListener((FocusListener)var1.readObject());
  3333.          } else if ("keyL" == var3) {
  3334.             this.addKeyListener((KeyListener)var1.readObject());
  3335.          } else if ("mouseL" == var3) {
  3336.             this.addMouseListener((MouseListener)var1.readObject());
  3337.          } else if ("mouseMotionL" == var3) {
  3338.             this.addMouseMotionListener((MouseMotionListener)var1.readObject());
  3339.          } else if ("inputMethodL" == var3) {
  3340.             this.addInputMethodListener((InputMethodListener)var1.readObject());
  3341.          } else {
  3342.             var1.readObject();
  3343.          }
  3344.       }
  3345.  
  3346.       Object var12 = null;
  3347.  
  3348.       try {
  3349.          var12 = var1.readObject();
  3350.       } catch (OptionalDataException var9) {
  3351.          if (!var9.eof) {
  3352.             throw var9;
  3353.          }
  3354.       }
  3355.  
  3356.       if (var12 != null) {
  3357.          this.componentOrientation = (ComponentOrientation)var12;
  3358.       } else {
  3359.          this.componentOrientation = ComponentOrientation.UNKNOWN;
  3360.       }
  3361.  
  3362.       try {
  3363.          while(null != (var2 = var1.readObject())) {
  3364.             String var4 = ((String)var2).intern();
  3365.             if ("hierarchyL" == var4) {
  3366.                this.addHierarchyListener((HierarchyListener)var1.readObject());
  3367.             } else if ("hierarchyBoundsL" == var4) {
  3368.                this.addHierarchyBoundsListener((HierarchyBoundsListener)var1.readObject());
  3369.             } else {
  3370.                var1.readObject();
  3371.             }
  3372.          }
  3373.       } catch (OptionalDataException var8) {
  3374.          if (!var8.eof) {
  3375.             throw var8;
  3376.          }
  3377.       }
  3378.  
  3379.       try {
  3380.          while(null != (var2 = var1.readObject())) {
  3381.             String var13 = ((String)var2).intern();
  3382.             if ("mouseWheelL" == var13) {
  3383.                this.addMouseWheelListener((MouseWheelListener)var1.readObject());
  3384.             } else {
  3385.                var1.readObject();
  3386.             }
  3387.          }
  3388.       } catch (OptionalDataException var7) {
  3389.          if (!var7.eof) {
  3390.             throw var7;
  3391.          }
  3392.       }
  3393.  
  3394.       if (this.popups != null) {
  3395.          int var14 = this.popups.size();
  3396.  
  3397.          for(int var5 = 0; var5 < var14; ++var5) {
  3398.             PopupMenu var6 = (PopupMenu)this.popups.elementAt(var5);
  3399.             var6.parent = this;
  3400.          }
  3401.       }
  3402.  
  3403.    }
  3404.  
  3405.    public void setComponentOrientation(ComponentOrientation var1) {
  3406.       ComponentOrientation var2 = this.componentOrientation;
  3407.       this.componentOrientation = var1;
  3408.       this.firePropertyChange("componentOrientation", var2, var1);
  3409.       if (this.valid) {
  3410.          this.invalidate();
  3411.       }
  3412.  
  3413.    }
  3414.  
  3415.    public ComponentOrientation getComponentOrientation() {
  3416.       return this.componentOrientation;
  3417.    }
  3418.  
  3419.    public void applyComponentOrientation(ComponentOrientation var1) {
  3420.       if (var1 == null) {
  3421.          throw new NullPointerException();
  3422.       } else {
  3423.          this.setComponentOrientation(var1);
  3424.       }
  3425.    }
  3426.  
  3427.    final boolean canBeFocusOwner() {
  3428.       if (this.isEnabled() && this.isDisplayable() && this.isVisible() && this.isFocusable()) {
  3429.          synchronized(this.getTreeLock()) {
  3430.             return this.parent != null ? this.parent.canContainFocusOwner(this) : true;
  3431.          }
  3432.       } else {
  3433.          return false;
  3434.       }
  3435.    }
  3436.  
  3437.    Window getContainingWindow() {
  3438.       return getContainingWindow(this);
  3439.    }
  3440.  
  3441.    static Window getContainingWindow(Component var0) {
  3442.       while(var0 != null && !(var0 instanceof Window)) {
  3443.          var0 = ((Component)var0).getParent();
  3444.       }
  3445.  
  3446.       return (Window)var0;
  3447.    }
  3448.  
  3449.    private static native void initIDs();
  3450.  
  3451.    public AccessibleContext getAccessibleContext() {
  3452.       return this.accessibleContext;
  3453.    }
  3454.  
  3455.    int getAccessibleIndexInParent() {
  3456.       synchronized(this.getTreeLock()) {
  3457.          int var2 = -1;
  3458.          Container var3 = this.getParent();
  3459.          if (var3 != null && var3 instanceof Accessible) {
  3460.             Component[] var4 = var3.getComponents();
  3461.  
  3462.             for(int var5 = 0; var5 < var4.length; ++var5) {
  3463.                if (var4[var5] instanceof Accessible) {
  3464.                   ++var2;
  3465.                }
  3466.  
  3467.                if (this.equals(var4[var5])) {
  3468.                   return var2;
  3469.                }
  3470.             }
  3471.          }
  3472.  
  3473.          return -1;
  3474.       }
  3475.    }
  3476.  
  3477.    AccessibleStateSet getAccessibleStateSet() {
  3478.       synchronized(this.getTreeLock()) {
  3479.          AccessibleStateSet var2 = new AccessibleStateSet();
  3480.          if (this.isEnabled()) {
  3481.             var2.add(AccessibleState.ENABLED);
  3482.          }
  3483.  
  3484.          if (this.isFocusTraversable()) {
  3485.             var2.add(AccessibleState.FOCUSABLE);
  3486.          }
  3487.  
  3488.          if (this.isVisible()) {
  3489.             var2.add(AccessibleState.VISIBLE);
  3490.          }
  3491.  
  3492.          if (this.isShowing()) {
  3493.             var2.add(AccessibleState.SHOWING);
  3494.          }
  3495.  
  3496.          if (this.isFocusOwner()) {
  3497.             var2.add(AccessibleState.FOCUSED);
  3498.          }
  3499.  
  3500.          if (this instanceof Accessible) {
  3501.             AccessibleContext var3 = ((Accessible)this).getAccessibleContext();
  3502.             if (var3 != null) {
  3503.                Accessible var4 = var3.getAccessibleParent();
  3504.                if (var4 != null) {
  3505.                   AccessibleContext var5 = var4.getAccessibleContext();
  3506.                   if (var5 != null) {
  3507.                      AccessibleSelection var6 = var5.getAccessibleSelection();
  3508.                      if (var6 != null) {
  3509.                         var2.add(AccessibleState.SELECTABLE);
  3510.                         int var7 = var3.getAccessibleIndexInParent();
  3511.                         if (var7 >= 0 && var6.isAccessibleChildSelected(var7)) {
  3512.                            var2.add(AccessibleState.SELECTED);
  3513.                         }
  3514.                      }
  3515.                   }
  3516.                }
  3517.             }
  3518.          }
  3519.  
  3520.          if (isInstanceOf(this, "javax.swing.JComponent") && ((JComponent)this).isOpaque()) {
  3521.             var2.add(AccessibleState.OPAQUE);
  3522.          }
  3523.  
  3524.          return var2;
  3525.       }
  3526.    }
  3527.  
  3528.    static boolean isInstanceOf(Object var0, String var1) {
  3529.       if (var0 == null) {
  3530.          return false;
  3531.       } else if (var1 == null) {
  3532.          return false;
  3533.       } else {
  3534.          for(Class var2 = var0.getClass(); var2 != null; var2 = var2.getSuperclass()) {
  3535.             if (var2.getName().equals(var1)) {
  3536.                return true;
  3537.             }
  3538.          }
  3539.  
  3540.          return false;
  3541.       }
  3542.    }
  3543.  
  3544.    // $FF: synthetic method
  3545.    static Insets access$000(Component var0) {
  3546.       return var0.getInsets_NoClientCode();
  3547.    }
  3548.  
  3549.    // $FF: synthetic method
  3550.    static boolean access$100(Class var0) {
  3551.       return isCoalesceEventsOverriden(var0);
  3552.    }
  3553.  
  3554.    static {
  3555.       Toolkit.loadLibraries();
  3556.       if (!GraphicsEnvironment.isHeadless()) {
  3557.          initIDs();
  3558.       }
  3559.  
  3560.       String var0 = (String)AccessController.doPrivileged(new GetPropertyAction("awt.image.incrementaldraw"));
  3561.       isInc = var0 == null || var0.equals("true");
  3562.       var0 = (String)AccessController.doPrivileged(new GetPropertyAction("awt.image.redrawrate"));
  3563.       incRate = var0 != null ? Integer.parseInt(var0) : 100;
  3564.       coalesceMap = new WeakHashMap();
  3565.       coalesceEventsParams = new Class[]{AWTEvent.class, AWTEvent.class};
  3566.       requestFocusController = new DummyRequestFocusController((1)null);
  3567.    }
  3568. }
  3569.